TM1637 Pantalla LED de 7 segmentos de 4 dígitos

Cómo usar la Pantalla TM1637 con Arduino

En este tutorial, aprenderás cómo puedes controlar una pantalla TM1637 con Arduino, esta pantalla es 4 dígitos de 7 segmentos. Estas pantallas son fantásticas para mostrar los datos de los sensores, la temperatura, la hora, etc.

Hemos incluido 3 ejemplos en este tutorial. En el primer ejemplo, veremos las funciones básicas de la biblioteca TM1637Display. En el segundo ejemplo, te mostraremos cómo puedes mostrar la hora en una pantalla de 4 dígitos. El último ejemplo puede utilizarse para crear una simple pantalla de temperatura en combinación con el DHT11.

También se incluyen diagramas de cableado. Después del ejemplo, desglosamos y explicamos cómo funciona el código, así que no deberías tener problemas para modificarlo según tus necesidades.

Lo que vas a necesitar

  • TM1637 Pantalla de 4 dígitos de 7 segmentos × 1
  • Arduino Uno Rev 3 Arduino Uno Rev3 × 1
  • Breadboard × 1
  • Cable puente ~ 10
  • DS3231 RTC × 1
  • Adafruit DS3231 Precisión RTC Breakout (alternativa) × 1
  • Sensor de temperatura y humedad DHT11 (3-pin) × 1
  • Cable USB tipo A/B × 1
  • Arduino IDE

Información sobre la pantalla TM1637

Las pantallas de 4 dígitos de 7 segmentos 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 la pantalla, este número puede reducirse a sólo cuatro. Se necesitan dos pines para las conexiones de energía y los otros dos pines se usan para controlar los segmentos.

Los displays de 7 segmentos contienen 7 (u 8) LEDs direccionables individualmente. Los segmentos están etiquetados de la A a la G y algunos displays también tienen un punto (el 8º LED). Utilice esta imagen como referencia cuando ajuste los segmentos individuales en el código más adelante.

division numeros display - TM1637 Pantalla LED de 7 segmentos de 4 dígitos

Puedes comprar muchos módulos de visualización diferentes que usan un IC TM1637. El color, el tamaño, los puntos y los puntos de conexión pueden ser todos diferentes. Siempre y cuando utilicen 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 he utilizado en este tutorial.

Especificaciones de la pantalla de 4 dígitos de 7 segmentos TM1637

Voltaje3.3 – 5 V
Consumo de corriente80 mA
Niveles de luminancia8
Dimensiones de la pantalla30 x 14 mm (0.36″ digits)
Dimensiones totales42 x 24 x 12 mm
Dimensiones del agujero38 x 20, ⌀ 2.2 mm
Temperatura de funcionamiento-10 – 80 °C

El IC TM1637 está hecho por Titan Micro Electronics. Para obtener más información, puede consultar la siguiente hoja de datos en este enlace.

Cableado. Conectando la pantalla de 4 dígitos de 7 segmentos TM1637 a Arduino UNO

Conectar la pantalla a un Arduino u otro microcontrolador es muy fácil. Sólo necesitas conectar 4 cables: 2 para la alimentación y 2 para la transferencia de datos.

El siguiente diagrama de cableado te muestra cómo puede conectar la pantalla a tu Arduino.

conectar TM1637 a Arduino Uno - TM1637 Pantalla LED de 7 segmentos de 4 dígitos

 

Las conexiones también se indican en el cuadro siguiente:

Conexiones de la pantalla TM1637

TM1637 Pantalla de 4 dígitosArduino
VCC5 V
GNDGND
CLKDigital pin 2
DIODigital pin 3

Ten en cuenta que el orden y la ubicación de los pines puede ser diferente dependiendo del fabricante.

Para este tutorial, conectamos CLK y DIO a los pines 2 y 3 respectivamente, pero puedes cambiarlo a cualquiera de los pines digitales que quieras. Sólo tienes que cambiar la configuración de los pines en el código en consecuencia.

Código de ejemplo de Arduino para pantalla TM1637

Avishay Orpaz ha escrito una excelente biblioteca para las pantallas TM1637, la biblioteca TM1637Display. Esta biblioteca tiene varias funciones incorporadas que hacen que el control de la pantalla sea bastante fácil.

Las principales funciones incluyen:

  • setSegments() – Establece el valor en bruto de los segmentos de cada dígito
  • showNumberDec() – Mostrar un número decimal
  • showNumberDecEx() – Muestra un número decimal con puntos o dos puntos decimales
  • setBrightness() – Establece el brillo de la pantalla
  • clear() – Borrar la pantalla

El ejemplo de código que figura a continuación presenta todas estas funciones. A continuación explicaremos con más detalle cómo se puede utilizar cada función.

Puedes subir el código de ejemplo a tu Arduino utilizando el IDE de Arduino.

Para instalar la librería, puedes descargarla como un .zip desde GitHub aquí. A continuación, ve a Sketch > Incluir la biblioteca > Añadir la biblioteca .ZIP… en el IDE de Arduino.

Otra opción es navegar a Herramientas > Administrar Bibliotecas… o escribir Ctrl + Shift + I en Windows. El Administrador de bibliotecas abrirá y actualizará la lista de bibliotecas instaladas.

Puedes buscar ‘tm1637’ y buscar la biblioteca por Avishay Orpaz. Selecciona la última versión y luego haga clic en Instalar:

instalar TM1637 - TM1637 Pantalla LED de 7 segmentos de 4 dígitos

Ejemplo de código

/* Example code for TM1637 4 digit 7 segment display with Arduino. More info: descubrearduino.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 con la inclusión de la biblioteca. Asegúrate de tener la biblioteca correcta instalada, 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 sentencia #define se usa para dar un nombre a un valor constante. El compilador reemplazará cualquier referencia a esta constante con el valor definido cuando el programa sea compilado. Así que en cualquier lugar que mencione CLK, el compilador lo reemplazará con el valor 2 cuando el programa sea compilado.

// Define the connections pins:
#define CLK 2
#define DIO 3

A continuación, creamos un objeto de visualización del tipo TM1637Display con los pines CLK y DIO definidos. Nota que llamamos al display ‘display’, pero puedes usar otros nombres como ‘temperature_display’.

El nombre que le des a la pantalla se usará más tarde para escribir datos en esa pantalla en particular. Puedes crear y controlar múltiples objetos de visualización con diferentes nombres y pines de conexión. Actualmente no hay ningún 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 maneras de controlar los segmentos individuales de la pantalla. Antes de la sección de configuración del código, especifiqué varios arreglos para configurar los segmentos individuales de la pantalla. Usaremos la función setSegments() más tarde para escribirlos en el display.

La primera opción es escribir números hexadecimales en el display para cada dígito. El hexadecimal 0xff se traduce a 11111111 en binario, esto pone todos los segmentos en (incluyendo el punto si su pantalla tiene uno). 0xef por ejemplo, se traduce a 11101111. Esto activaría todos los segmentos, excepto el segmento E. Observe que el conteo va de derecha a izquierda, por lo que 11111111 corresponde a los segmentos (dot)GFEDCBA. Puedes encontrar una tabla de conversión de hexadecimal a binario aquí.

// 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 incorporada que facilita la configuración de los segmentos individuales. Mira el fragmento de código a continuación. Puedes crear matrices para deletrear palabras. Cada segmento está separado por un | y los dígitos de la pantalla están separados 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
};

Puedes dejar la sección de configuración del código vacía si quieres. Podemos usar la función clear() para asegurarnos de que la pantalla se ha borrado.

void setup() {
  // Clear the display:
  display.clear();
  delay(1000);
}

En la sección de bucle del código, mostramos varios ejemplos de las diferentes funciones de la biblioteca:

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

Esta función puede utilizarse para ajustar los segmentos individuales de la pantalla. El primer argumento es la matriz que incluye la información del segmento. El segundo argumento especifica el número de dígitos a modificar (0-4). Si quieres escribir dOnE, este sería 4, para un símbolo de °C, este sería 2. El tercer argumento establece la posición desde la que se imprime (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 puede ser omitido.

showNumberDec(number, leading_zeros, length, position)

Esta es probablemente la función que más utilizarás. El primer argumento es un número que quieres mostrar en la pantalla. El resto de los argumentos son opcionales.

El segundo argumento puede usarse para activar o desactivar los ceros iniciales. 10 sin ceros a la izquierda se imprimiría como __10 y con ceros a la izquierda como 0010. Puede activarlos estableciendo este argumento como verdadero o desactivarlos estableciéndolo como falso. NOTA: el cero inicial no se admite con números negativos.

El tercer y cuarto argumento son los mismos 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 permite controlar los puntos de la pantalla. Sólo el segundo argumento es diferente de la función showNumberDec. Te permite poner los puntos entre los dígitos individuales.

Puedes utilizar los siguientes valores.

Para pantallas con puntos entre cada dígito:

  • 0b10000000 – 0.000
  • 0b01000000 – 00.00
  • 0b00100000 – 000.0
  • 0b11100000 – 0.0.0.0

Para pantallas con sólo dos puntos:

  • 0b01000000 – 00:00

Para pantallas con puntos y dos puntos:

  • 0b11100000 – 0.0:0.0

Así que si quieres mostrar un reloj con los dos puntos centrales activados (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). Se puede especificar un nivel de brillo desde 0 (brillo más bajo) hasta 7 (brillo más alto). El segundo parámetro puede utilizarse para encender o apagar la pantalla, “falso” significa “apagado”.

// Set the display brightness (0-7):
display.setBrightness(7);

Ejemplo de reloj: TM1637 Pantalla de 4 dígitos de 7 segmentos con DS3231 RTC

Uno de los usos típicos de una pantalla de 4 dígitos de 7 segmentos es mostrar la hora. Combinando el TM1637 con un módulo de reloj en tiempo real (RTC), se puede crear fácilmente un reloj de 24 horas.

En este ejemplo utilizamos este módulo RTC DS3231 de uso habitual. Este módulo se comunica con el Arduino a través de I2C, por lo que sólo necesitas dos conexiones para leer la hora.

El siguiente diagrama de cableado muestra cómo se puede conectar el DS3231 RTC al Arduino. Ten en cuenta que la pantalla TM1637 está conectada de la misma manera que antes.

TM1637 con DS3231 RTC y Arduino UNO - TM1637 Pantalla LED de 7 segmentos de 4 dígitos

Las conexiones también se dan en la tabla siguiente:

Conexiones DS3231 RTC

DS3231Arduino
VCC5 V
GNDGND
SDAA4
SCLA5

El siguiente ejemplo de código puede utilizarse para mostrar la hora en un formato de tiempo de 24 horas. Si tu pantalla tiene los dos puntos centrales, este código la hará parpadear. También puedes desactivarlo 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 código.

Puedes instalar una batería de pilas de monedas en la parte trasera del módulo, para que el tiempo se almacene en caso de que pierda energía. Aparentemente el circuito de carga de la mayoría de los módulos chinos puede sobrecargar la batería de la pila de monedas, así que tal vez quieras comprar un módulo DS3231 de Adafruit en su lugar.

El código utiliza la biblioteca RTC de Adafruit, que puedes descargar aquí en GitHub. También puedes instalarla a través del Administrador de la Biblioteca en el IDE de Arduino buscando ‘RTClib’.

/* Arduino example code to display a 24 hour time format clock on a TM1637 4 digit 7 segment display with a DS32321 RTC. More info: descubrearduino.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: TM1637 Pantalla de 4 dígitos de 7 segmentos con sensor de temperatura y humedad DHT11

Las pantallas de 4 dígitos de 7 segmentos son excelentes para mostrar las lecturas de los sensores como la temperatura, la humedad, el voltaje o la velocidad. En el siguiente ejemplo, te mostraremos cómo puedes mostrar las lecturas de temperatura en la pantalla TM1637. Usaremos el popular sensor de temperatura y humedad DHT11.

El siguiente diagrama de cableado le muestra cómo puede conectar el sensor DHT11 en combinación con la pantalla TM1637 al Arduino. Ten en cuenta que la pantalla TM1637 se conecta de la misma manera que antes.

TM1637 con DHT11 - TM1637 Pantalla LED de 7 segmentos de 4 dígitos

 

Las conexiones también se indican en el cuadro siguiente:

Conexiones DHT11

DHT11Arduino
+5 V
GND
sDigital pin 4

Ten en cuenta que el orden de los pines puede ser diferente, dependiendo del fabricante.

El código de ejemplo que figura a continuación puede utilizarse para mostrar las lecturas de temperatura en la pantalla. Alterna entre la temperatura en Celios y en Fahrenheit, ambas se muestran durante 2 segundos.

La función setSegments() se utiliza para mostrar los símbolos de Celsius y Fahrenheit. El código utiliza la librería de sensores Adafruit DHT que puede descargar aquí en GitHub. Esta librería sólo funciona si también tienes instalada la librería Adafruit Unified Sensor, que también está disponible en GitHub.

/* Arduino example sketch to display DHT11 temperature readings on a TM1637 4-digit 7-segment display. More info: descubrearduino.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 os hemos mostrado cómo se puede utilizar una pantalla de 4 dígitos de 7 segmentos TM1637 con Arduino. También hemos visto un ejemplo de reloj y termómetro. Esperamos que lo hayas encontrado útil e informativo.

Es muy útil usar estas pantallas para mostrar las lecturas de los sensores o cosas como la velocidad de un motor. Con la librería TM1637Display, la programación de los displays se hace muy fácil, así que no hay razón para no incorporar una en tu próximo proyecto.

Pin It on Pinterest

Shares