En este tutorial, aprenderás cómo controlar pantallas TM1637 de 4 dígitos y 7 segmentos con Arduino. Estas pantallas son fantásticas para mostrar datos de sensores, temperatura, hora, etc.
He incluido 3 ejemplos en este tutorial. En el primer ejemplo, veremos las funciones básicas de la biblioteca TM1637Display. En el segundo ejemplo, te mostraré cómo puedes mostrar la hora en una pantalla de 4 dígitos. El último ejemplo se puede usar para crear un sencillo display de temperatura en combinación con el DHT11.
Materiales
Componentes de hardware
Software
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Información sobre la pantalla
Las pantallas de 4 dígitos y 7 segmentos sin módulo suelen requerir 12 pines de conexión. Eso es bastante y no deja mucho espacio para otros sensores o módulos. Gracias al IC TM1637 montado en la parte trasera del módulo de pantalla, este número se reduce a solo cuatro. Dos pines son para la alimentación y los otros dos se usan para controlar los segmentos.
Las pantallas de 7 segmentos contienen 7 (u 8) LEDs direccionables individualmente. Los segmentos están etiquetados de la A a la G y algunas pantallas también tienen un punto (el 8º LED). Usa esta imagen como referencia para configurar los segmentos individuales en el código más adelante.
Puedes comprar muchos módulos de pantalla diferentes que usan un IC TM1637. El color, tamaño, puntos y puntos de conexión pueden variar. No tengo experiencia con todas las versiones de esta pantalla, pero mientras usen el TM1637, los ejemplos de código que se proporcionan a continuación deberían funcionar.
Aquí puedes encontrar las especificaciones básicas del módulo de pantalla que usé en este tutorial.
Especificaciones de la pantalla TM1637 de 4 dígitos y 7 segmentos
| Voltaje de funcionamiento | 3.3 – 5 V |
| Consumo de corriente | 80 mA |
| Niveles de luminancia | 8 |
| Dimensiones de la pantalla | 30 x 14 mm (dígitos de 0.36″) |
| Dimensiones totales | 42 x 24 x 12 mm |
| Dimensiones de los orificios | 38 x 20, ⌀ 2.2 mm |
| Temperatura de funcionamiento | -10 – 80 °C |
| Costo | Check price |
El IC TM1637 es fabricado por Titan Micro Electronics. Para más información, puedes consultar la hoja de datos a continuación:
Cableado – Conectar pantalla TM1637 de 4 dígitos y 7 segmentos a Arduino UNO
Conectar la pantalla a un Arduino u otro microcontrolador es muy fácil. Solo necesitas conectar 4 cables: 2 para la alimentación y 2 para transferir los datos.
El diagrama de cableado a continuación muestra cómo conectar la pantalla al Arduino.
Las conexiones también se muestran en la tabla a continuación:
Conexiones de la pantalla TM1637
| Pantalla TM1637 de 4 dígitos | Arduino |
|---|---|
| VCC | 5 V |
| GND | GND |
| CLK | Pin digital 2 |
| DIO | Pin digital 3 |
Ten en cuenta que el orden y la ubicación de los pines pueden variar según el fabricante.
Para este tutorial, conecté CLK y DIO a los pines 2 y 3 respectivamente, pero puedes cambiarlos a cualquier pin digital que desees. Solo tienes que modificar la configuración de pines en el código en consecuencia.
Ejemplo de código Arduino para pantalla TM1637 de 4 dígitos y 7 segmentos
Avishay Orpaz ha escrito una excelente biblioteca para pantallas TM1637, la TM1637Display library. Esta biblioteca tiene varias funciones integradas que facilitan el control de la pantalla.
Las funciones principales incluyen:
- setSegments() – Establece el valor bruto de los segmentos de cada dígito
- showNumberDec() – Muestra un número decimal
- showNumberDecEx() – Muestra un número decimal con puntos decimales o dos puntos
- setBrightness() – Ajusta el brillo de la pantalla
- clear() – Limpia la pantalla
El ejemplo de código a continuación incluye todas estas funciones. Explicaré cómo usar cada función con más detalle más adelante.
Puedes subir el código de ejemplo a tu Arduino usando el Arduino IDE.
Para instalar la biblioteca, puedes descargarla como un archivo .zip desde Github. Luego, ve a Sketch > Include Library > Add .ZIP Library… en el Arduino IDE.
Otra opción es ir a Tools > Manage Libraries… o presionar Ctrl + Shift + I en Windows. Se abrirá el Library Manager y actualizará la lista de bibliotecas instaladas.
Puedes buscar ‘tm1637’ y buscar la biblioteca de Avishay Orpaz. Selecciona la versión más reciente y haz clic en Instalar.
Código de ejemplo
Puedes copiar el código haciendo clic en el botón en la esquina superior derecha del campo de código.
/* Example code for TM1637 4 digit 7 segment display with Arduino.
www.www.makerguides.com */
// Include the library:
#include "TM1637Display.h"
// Define the connections pins:
#define CLK 2
#define DIO 3
// Create display object of type TM1637Display:
TM1637Display display = TM1637Display(CLK, DIO);
// Create array that turns all segments on:
const uint8_t data[] = {0xff, 0xff, 0xff, 0xff};
// Create array that turns all segments off:
const uint8_t blank[] = {0x00, 0x00, 0x00, 0x00};
// You can set the individual segments per digit to spell words or create other symbols:
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, // Circle
SEG_A | SEG_D | SEG_E | SEG_F // C
};
void setup() {
// Clear the display:
display.clear();
delay(1000);
}
void loop() {
// Set the brightness:
display.setBrightness(7);
// All segments on:
display.setSegments(data);
delay(1000);
display.clear();
delay(1000);
// Show counter:
int i;
for (i = 0; i < 101; i++) {
display.showNumberDec(i);
delay(50);
}
delay(1000);
display.clear();
delay(1000);
// Print number in different locations, loops 2 times:
int j;
for (j = 0; j < 2; j++) {
for (i = 0; i < 4; i++) {
display.showNumberDec(i, false, 1, i);
delay(500);
display.clear();
}
}
delay(1000);
display.clear();
delay(1000);
// Set brightness (0-7):
int k;
for (k = 0; k < 8; k++) {
display.setBrightness(k);
display.setSegments(data);
delay(500);
}
delay(1000);
display.clear();
delay(1000);
// Print 1234 with the center colon:
display.showNumberDecEx(1234, 0b11100000, false, 4, 0);
delay(1000);
display.clear();
delay(1000);
int temperature = 24;
display.showNumberDec(temperature, false, 2, 0);
display.setSegments(celsius, 2, 2);
delay(1000);
display.clear();
delay(1000);
display.setSegments(done);
while(1);
}
Cómo funciona el código:
El código comienza incluyendo la biblioteca. Asegúrate de tener instalada la biblioteca correcta, de lo contrario recibirás un mensaje de error al compilar el código.
// Include the library: #include "TM1637Display.h"
El siguiente paso es especificar los pines de conexión. La instrucción #define se usa para dar un nombre a un valor constante. El compilador reemplazará cualquier referencia a esta constante con el valor definido cuando se compile el programa. Así que donde menciones CLK, el compilador lo reemplazará con el valor 2 al compilar el programa.
// Define the connections pins: #define CLK 2 #define DIO 3
Iniciar pantalla
Luego, creamos un objeto de pantalla del tipo TM1637Display con los pines CLK y DIO definidos. Ten en cuenta que llamé a la pantalla ‘display’, pero puedes usar otros nombres como ‘temperature_display’.
El nombre que le des a la pantalla se usará más adelante para escribir datos en esa pantalla en particular. Puedes crear y controlar múltiples objetos de pantalla con diferentes nombres y pines de conexión. Actualmente no hay límite en la biblioteca.
// Create display object of type TM1637Display: TM1637Display display = TM1637Display(CLK, DIO); // You can create more than one display object. Give them different names and connection pins: TM1637Display display_1 = TM1637Display(2, 3); TM1637Display display_2 = TM1637Display(4, 5); TM1637Display display_3 = TM1637Display(6, 7);
Hay varias formas de controlar los segmentos individuales de la pantalla. Antes de la sección setup del código, especifiqué varios arrays para configurar los segmentos individuales de la pantalla. Usaremos la función setSegments() más adelante para escribirlos en la pantalla.
La primera opción es escribir números hexadecimales en la pantalla para cada dígito. El hexadecimal 0xff se traduce a 11111111 en binario, esto enciende todos los segmentos (incluido el punto si tu pantalla tiene uno). 0xef, por ejemplo, se traduce a 11101111. Esto encendería todos los segmentos excepto el segmento E. Ten en cuenta que la cuenta va de derecha a izquierda, así que 11111111 corresponde a los segmentos (punto)GFEDCBA.
// Create array that turns all segments on:
const uint8_t data[] = {0xff, 0xff, 0xff, 0xff};
// Create array that turns all segments off:
const uint8_t blank[] = {0x00, 0x00, 0x00, 0x00};
La biblioteca tiene una función integrada que facilita configurar segmentos individuales. Mira el fragmento de código a continuación. Puedes crear arrays para formar palabras. Cada segmento está separado por un | y los dígitos de la pantalla por una coma.
// You can set the individual segments per digit to spell words or create other symbols:
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
};
Función setup
Puedes dejar la sección setup del código vacía si quieres. Yo solo usé la función clear() para asegurar que la pantalla estuviera limpia.
void setup() {
// Clear the display:
display.clear();
delay(1000);
}
Función loop
En la sección loop del código, muestro varios ejemplos de las diferentes funciones de la biblioteca:
setSegments(segments[ ], length, position)
Esta función se usa para configurar los segmentos individuales de la pantalla. El primer argumento es el array que incluye la información de los segmentos. El segundo argumento especifica el número de dígitos a modificar (0-4). Si quieres escribir dOnE, serían 4; para un símbolo °C, serían 2. El tercer argumento establece la posición desde donde imprimir (0 – más a la izquierda, 3 – más a la derecha). Así que si quieres imprimir un símbolo °C en el tercer y cuarto dígito, usarías:
// Create degree Celsius symbol:
const uint8_t celsius[] = {
SEG_A | SEG_B | SEG_F | SEG_G, // Circle
SEG_A | SEG_D | SEG_E | SEG_F // C
};
display.setSegments(celsius, 2, 2);
El segundo y tercer argumento de la función también pueden omitirse.
showNumberDec(number, leading_zeros, length, position)
Probablemente esta sea la función que usarás más. El primer argumento es un número que quieres mostrar en la pantalla. El resto de argumentos son opcionales.
El segundo argumento se usa para activar o desactivar los ceros a la izquierda. 10 sin ceros a la izquierda se mostraría como __10 y con ceros a la izquierda como 0010. Puedes activarlos poniendo este argumento en true o desactivarlos poniéndolo en false. NOTA: los ceros a la izquierda no se soportan con números negativos.
El tercer y cuarto argumento son iguales que en la función anterior.
// Print the number 12 without leading zeros on the second and third digit: display.showNumberDec(12, false, 2, 1);
showNumberDecEx(number, dots, leading_zeros, length, position)
Esta función te permite controlar los puntos de la pantalla. Solo el segundo argumento es diferente de la función showNumberDec. Permite configurar los puntos entre los dígitos individuales.
Puedes usar los siguientes valores.
Para pantallas con puntos entre cada dígito usa
- 0b10000000 – 0.000
- 0b01000000 – 00.00
- 0b00100000 – 000.0
- 0b11100000 – 0.0.0.0
para pantallas con solo dos puntos usa
- 0b01000000 – 00:00
y para pantallas con puntos y dos puntos usa
- 0b11100000 – 0.0:0.0
Así que si quieres mostrar un reloj con el dos puntos central encendido (ver ejemplo de reloj abajo), usarías algo como:
// Print 1234 with the center colon: display.showNumberDecEx(1234, 0b11100000, false, 4, 0);
setBrightness(brightness, true/false)
Esta función ajusta el brillo de la pantalla (como su nombre indica). Puedes especificar un nivel de brillo de 0 (brillo más bajo) a 7 (brillo más alto). El segundo parámetro se usa para encender o apagar la pantalla, false significa apagado.
// Set the display brightness (0-7): display.setBrightness(7);
Ejemplo de reloj: pantalla TM1637 de 4 dígitos y 7 segmentos con RTC DS3231
Uno de los usos típicos para una pantalla de 4 dígitos y 7 segmentos es mostrar la hora. Combinando el TM1637 con un módulo de reloj en tiempo real (RTC), puedes crear fácilmente un reloj de 24 horas.
En este ejemplo usé este comúnmente usado DS3231 RTC module. Este módulo se comunica con el Arduino vía I2C, por lo que solo necesitas dos conexiones para leer la hora.
El diagrama de cableado a continuación muestra cómo conectar el RTC DS3231 al Arduino. Ten en cuenta que la pantalla TM1637 está conectada igual que antes.
Las conexiones también se muestran en la tabla a continuación:
Conexiones RTC DS3231
| DS3231 | Arduino |
|---|---|
| VCC | 5 V |
| GND | GND |
| SDA | A4 |
| SCL | A5 |
El siguiente ejemplo de código puede usarse para mostrar la hora en formato de 24 horas. Si tu pantalla tiene un dos puntos central, este código hará que parpadee. También puedes desactivar esto eliminando las últimas líneas de código.
La primera vez que subas el código, el RTC se ajustará a la hora en que se compiló el sketch.
Puedes instalar una batería de botón en la parte trasera del módulo para que la hora se mantenga en caso de que pierda energía. Al parecer, el circuito de carga de la mayoría de los módulos chinos puede sobrecargar la batería de botón (link), por lo que quizás quieras comprar una DS3231 module de Adafruit en su lugar.
El código usa la biblioteca RTC de Adafruit, que puedes descargar en GitHub. También puedes instalarla vía el Library Manager en el Arduino IDE buscando «RTClib», o hacer clic en el botón de descarga abajo:
Código de ejemplo
/* Arduino example code to display a 24 hour time format clock on a
TM1637 4 digit 7 segment display with a DS32321 RTC.
www.www.makerguides.com */
// Include the libraries:
#include "RTClib.h"
#include "TM1637Display.h"
// Define the connections pins:
#define CLK 2
#define DIO 3
// Create rtc and display object:
RTC_DS3231 rtc;
TM1637Display display = TM1637Display(CLK, DIO);
void setup() {
// Begin serial communication at a baud rate of 9600:
Serial.begin(9600);
// Wait for console opening:
delay(3000);
// Check if RTC is connected correctly:
if (!rtc.begin()) {
Serial.println("Couldn't find RTC");
while (1);
}
// Check if the RTC lost power and if so, set the time:
if (rtc.lostPower()) {
Serial.println("RTC lost power, lets set the time!");
// The following line sets the RTC to the date & time this sketch was compiled:
rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
// This line sets the RTC with an explicit date & time, for example to set
// January 21, 2014 at 3am you would call:
//rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));
}
// Set the display brightness (0-7):
display.setBrightness(5);
// Clear the display:
display.clear();
}
void loop() {
// Get current date and time:
DateTime now = rtc.now();
// Create time format to display:
int displaytime = (now.hour() * 100) + now.minute();
// Print displaytime to the Serial Monitor:
Serial.println(displaytime);
// Display the current time in 24 hour format with leading zeros enabled and a center colon:
display.showNumberDecEx(displaytime, 0b11100000, true);
// Remove the following lines of code if you want a static instead of a blinking center colon:
delay(1000);
display.showNumberDec(displaytime, true); // Prints displaytime without center colon.
delay(1000);
}
Ejemplo de termómetro: pantalla TM1637 de 4 dígitos y 7 segmentos con sensor de temperatura y humedad DHT11
Las pantallas de 4 dígitos y 7 segmentos son ideales para mostrar lecturas de sensores como temperatura, humedad, voltaje o velocidad. En el siguiente ejemplo, te mostraré cómo mostrar lecturas de temperatura en la pantalla TM1637.
Usaremos el popular DHT11 sensor de temperatura y humedad. El diagrama de cableado a continuación muestra cómo conectar el sensor DHT11 en combinación con la pantalla TM1637 al Arduino.
Ten en cuenta que la pantalla TM1637 está conectada igual que antes.
Las conexiones también se muestran en la tabla a continuación:
Conexiones DHT11
| DHT11 | Arduino |
|---|---|
| + | 5 V |
| – | GND |
| s | Pin digital 4 |
Ten en cuenta que el orden de los pines puede variar según el fabricante.
Si quieres usar un sensor de 4 pines, consulta mi tutorial para los sensores de temperatura y humedad DHT11 y DHT22: How to use DHT11 and DHT22 Sensors with Arduino.
El código de ejemplo a continuación puede usarse para mostrar las lecturas de temperatura en la pantalla. Alterna entre la temperatura en Celsius y Fahrenheit, mostrando ambos durante 2 segundos.
La función setSegments() se usa para mostrar los símbolos de Celsius y Fahrenheit.
El código usa la biblioteca de sensores DHT de Adafruit, que puedes descargar en GitHub. Esta biblioteca solo funciona si también tienes instalada la biblioteca Adafruit Unified Sensor, que también está disponible en GitHub.
También puedes descargar las dos bibliotecas haciendo clic en los botones a continuación:
Código de ejemplo
/* Arduino example sketch to display DHT11 temperature readings
on a TM1637 4-digit 7-segment display.
www.www.makerguides.com */
// Include the libraries:
#include "TM1637Display.h"
#include "Adafruit_Sensor.h"
#include "DHT.h"
// Define the connections pins:
#define CLK 2
#define DIO 3
#define DHTPIN 4
// Create variable:
int temperature_celsius;
int temperature_fahrenheit;
// Create degree Celsius symbol:
const uint8_t celsius[] = {
SEG_A | SEG_B | SEG_F | SEG_G, // Circle
SEG_A | SEG_D | SEG_E | SEG_F // C
};
// Create degree Fahrenheit symbol:
const uint8_t fahrenheit[] = {
SEG_A | SEG_B | SEG_F | SEG_G, // Circle
SEG_A | SEG_E | SEG_F | SEG_G // F
};
// Set DHT type, uncomment whatever type you're using!
#define DHTTYPE DHT11 // DHT 11
//#define DHTTYPE DHT22 // DHT 22 (AM2302)
//#define DHTTYPE DHT21 // DHT 21 (AM2301)
// Create display object of type TM1637Display:
TM1637Display display = TM1637Display(CLK, DIO);
// Create dht object of type DHT:
DHT dht = DHT(DHTPIN, DHTTYPE);
void setup() {
// Set the display brightness (0-7):
display.setBrightness(0);
// Clear the display:
display.clear();
// Setup sensor:
dht.begin();
// Begin serial communication at a baud rate of 9600:
Serial.begin(9600);
// Wait for console opening:
delay(2000);
}
void loop() {
// Read the temperature as Celsius and Fahrenheit:
temperature_celsius = dht.readTemperature();
temperature_fahrenheit = dht.readTemperature(true);
// Print the temperature to the Serial Monitor:
Serial.println(temperature_celsius);
Serial.println(temperature_fahrenheit);
// Show the temperature on the TM1637 display:
display.showNumberDec(temperature_celsius, false, 2, 0);
display.setSegments(celsius, 2, 2);
delay(2000);
display.showNumberDec(temperature_fahrenheit, false, 2, 0);
display.setSegments(fahrenheit, 2, 2);
delay(2000);
}
Conclusión
En este artículo te he mostrado cómo usar una pantalla TM1637 de 4 dígitos y 7 segmentos con Arduino. También vimos ejemplos de reloj y termómetro.
Para más tutoriales sobre pantallas, consulta nuestros How to control a character I2C LCD with Arduino y How to use a 16×2 character LCD with Arduinotutoriales.
Si tienes alguna pregunta, por favor deja un comentario abajo.
