En este artículo, te mostraré cómo funciona el controlador de LED de 7 segmentos TM1638 y cómo conectarlo a un Arduino UNO.
He usado el controlador de LED TM1638 en proyectos anteriores, ya que descarga una gran cantidad de trabajo del MCU principal. Añadir el controlador de LED a tu proyecto es fácil y sencillo.
Comenzaré explicándote las especificaciones del controlador de LED, compartiendo consejos y trucos, y mostrándote cómo mostrar dígitos y escanear los botones.
Luego entraremos en más detalle y veremos la guía de conexión y el código Arduino para la interfaz de datos paralela LCD del controlador TM1638. También responderemos preguntas frecuentes.
¡Prepara tu placa Arduino y comencemos!
Componentes necesarios para construir el proyecto Arduino y TM1638
Componentes de hardware
- Arduino UNO x 1
- Arduino Compatible TM1638 display module x 1
- Dupont wire x 1 set
- USB Cable for Arduino Programming x 1
Software
Fundamentos del módulo controlador de LED TM1638
Primero, entendamos las principales características del controlador de LED TM1638:
- Controla 8 dígitos (7 segmentos)
- Conduce 8 LEDs
- Escanea ocho interruptores táctiles
- Puedes controlar el brillo
- Interfaz serial – CLK, DIO, STB
La conexión típica entre el Arduino y el controlador TM1638 se muestra en la imagen siguiente.
En la siguiente sección, aprenderemos sobre las interfaces entre varios periféricos y el TM1638.
Detalles de los pines del controlador de LED TM1638
| Nombre del pin | Tipo de pin | Descripción del pin |
| DIO | Entrada/salida de datos | Datos seriales entre Arduino y el controlador TM1638 |
| STB | Selección de chip | Inicializa la interfaz serial durante el flanco de bajada/subida, luego recibe la instrucción. El primer byte es la instrucción cuando STB está bajo. CLK se ignora cuando STB está alto. |
| CLK | Entrada de reloj | Entrada de datos seriales |
| K1 ~ K3 | Entrada de datos de escaneo de teclas | Los datos introducidos en el pin se almacenan después de que finaliza el ciclo de visualización. |
| SEG1/KS1 ~ SEG8/KS8 | Salida (segmento) | Salida de segmento. Salida de drenaje abierto. |
| SEG9 ~ SEG10 | Salida (segmento) | Salida de segmento. Salida de drenaje abierto. |
| GRID1 ~ GRID8 | Salida (rejilla) | Salida de rejilla. Salida de drenaje abierto. |
| VDD | Alimentación lógica | 5 V ± 10% |
| GND | Masa lógica | Conexiones a tierra |
Una nota especial sobre el pin DIO: El pin Digital-Input-Output (DIO) en el módulo TM1638 es un N-type open drain. Debes proporcionar una resistencia pull-up externa para llevar la línea DIO a nivel lógico alto. El valor recomendado es 10 kOhms. Ver circuito abajo:
Escaneo de teclas y registro de datos de escaneo
La tasa de cuadro del escaneo de teclas es de 8 x 3 bits. Es similar a filas y columnas. Puedes considerarlo como una matriz de ocho filas y tres columnas. Esto significa que puedes usar hasta 24 botones pulsadores.
En la imagen siguiente, puedes ver cómo utilizar los pines K y KS del chip TM1638 para escanear 24 botones
Conjunto de instrucciones
Puedes usar los bits B7 y B6 del bit DIO para decidir el tipo de instrucción. El IC TM1638 usa el siguiente mecanismo de decodificación para identificar el tipo de instrucción enviada por el Arduino.
| B7 | B6 | Instrucción |
| 0 | 1 | Conjunto de instrucciones de datos |
| 1 | 0 | Conjunto de instrucciones de control de pantalla |
| 1 | 1 | Conjunto de instrucciones de dirección |
Conjunto de instrucciones de datos .
Normalmente, usarás principalmente el conjunto de instrucciones de datos. Es responsable de la lectura y escritura de datos. Nota: B1 y B0 no deben configurarse en 01 ni 11 para este conjunto de instrucciones.
| B7 | B6 | B5 | B4 | B3 | B2 | B1 | B0 | Función | Instrucción |
| 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | Modo de escritura de datos establecido | Escribir datos en el registro |
| 0 | 1 | 0 | 0 | 0 | 0 | 1 | 0 | Leer datos de escaneo de teclas | |
| 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | Modo de adición de dirección establecido | Adición automática de dirección |
| 0 | 1 | 0 | 0 | 0 | 1 | 0 | 0 | Dirección fija | |
| 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | Modo de prueba | Modo normal |
| 0 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | Modo de prueba |
En las imágenes siguientes, puedes ver el patrón de temporización y reloj tanto para escritura como para lectura del IC TM1638.
Ten en cuenta que al leer datos del chip, debes insertar al menos un retardo de 1 us entre la instrucción y la recepción de datos. Esto es obligatorio.
Para saber cómo conectar los pines de la pantalla TM1638 al display LED de 7 segmentos, consulta la imagen siguiente. El ejemplo es para un display de cátodo común, donde todos los pines de cátodo de los LEDs están conectados juntos.
Una alternativa es el display de ánodo común, donde todos los pines de ánodo de los LEDs están conectados juntos.
Es importante conocer las especificaciones eléctricas del chip con el que trabajas. Esto te ayudará a depurar y también a evitar dañar el chip. Cuanto más sepas sobre las especificaciones del IC, más fácil será hacer conexiones y construir circuitos fiables.
A continuación, las especificaciones eléctricas del controlador de LED TM1638:
| Parámetro | Rango |
| Voltaje de alimentación lógica | Típico 5 V |
| Voltaje de entrada alto | Mínimo 0.7 x VDD |
| Voltaje de entrada bajo | Máximo 0.3 x VDD |
| Corriente de salida en nivel alto | Máximo 40 mA |
| Corriente de salida en nivel bajo | Máximo 140 mA |
| Consumo de corriente activo | Máximo 5 mA |
| Frecuencia máxima de reloj | 1 MHz |
| Capacidad de entrada | 15 pF |
Basta de teoría ; ) En las siguientes secciones, ¡construyamos el proyecto!
Cómo conectar el TM1638 al Arduino UNO
Ahora te mostraré cómo construir un proyecto usando Arduino UNO y el módulo de pantalla TM1638. Comencemos con las conexiones de hardware.
Aquí tienes un resumen de las conexiones necesarias para conectar el Arduino UNO al módulo TM1638. Espero que te dé una visión general de la conexión. Sigue la guía para los detalles.
| Pin en el módulo TM1638 | Pin en Arduino UNO | Observaciones |
| VCC | 5 V | Alimentación |
| GND | GND | Conexiones a tierra |
| STB | Línea de strobe, pin 8 | Cualquier pin IO |
| CLK | Línea de datos, pin 9 | Cualquier pin IO |
| DIO | Línea de reloj, pin 10 | Cualquier pin IO |
Paso 1: Completa la conexión entre TM1638 y Arduino UNO
Aquí está el diagrama de conexión entre Arduino UNO y el chip TM1638.
Los datos seriales usan solo dos cables. Esto te ayuda a ahorrar pines en la placa y reduce la cantidad de cables.
El protocolo serial usado por TM1638 no es estándar. Pero no te preocupes. ¡Hay excelentes librerías que puedes usar! Puedes encontrar una de estas librerías here.
Recuerda siempre comenzar con las conexiones a tierra. Espera para alimentar el proyecto hasta que todas las conexiones estén hechas.
Paso 2: Programa el código Arduino UNO a continuación
Sigue el siguiente paso para entender la implementación del código. Puedes usar el código abajo para probar el módulo TM1638. No usamos librerías aquí.
const int strobe = 8; // STB to D8
const int clock = 9; // CLK to D9
const int data = 10; // DIO to D10
void sendCommand(uint8_t value)
{
digitalWrite(strobe, LOW);
shiftOut(data, clock, LSBFIRST, value);
digitalWrite(strobe, HIGH);
}
void reset()
{
sendCommand(0x40); // Set auto increment mode
digitalWrite(strobe, LOW);
shiftOut(data, clock, LSBFIRST, 0xc0); // Set starting address to 0
for (uint8_t i = 0; i < 16; i++)
{
shiftOut(data, clock, LSBFIRST, 0x00);
}
digitalWrite(strobe, HIGH);
}
void setup()
{
pinMode(strobe, OUTPUT);
pinMode(clock, OUTPUT);
pinMode(data, OUTPUT);
sendCommand(0x8f); // Set maximum display brightness
reset();
}
#define COUNTING_MODE 0
#define SCROLL_MODE 1
#define BUTTON_MODE 2
void loop()
{
static uint8_t mode = COUNTING_MODE;
switch (mode)
{
case COUNTING_MODE:
mode += counting();
delay(500);
break;
case SCROLL_MODE:
mode += scroll();
break;
case BUTTON_MODE:
buttons();
break;
}
delay(200);
}
bool counting()
{
/*0*/ /*1*/ /*2*/ /*3*/ /*4*/ /*5*/ /*6*/ /*7*/ /*8*/ /*9*/
uint8_t digits[] = { 0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f };
static uint8_t digit = 0;
sendCommand(0x40);
digitalWrite(strobe, LOW);
shiftOut(data, clock, LSBFIRST, 0xc0);
for (uint8_t position = 0; position < 8; position++)
{
shiftOut(data, clock, LSBFIRST, digits[digit]);
shiftOut(data, clock, LSBFIRST, 0x00);
}
digitalWrite(strobe, HIGH);
digit = ++digit % 10;
return digit == 0;
}
bool scroll()
{
uint8_t scrollText[] =
{
/* */ /* */ /* */ /* */ /* */ /* */ /* */ /* */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/*H*/ /*E*/ /*L*/ /*L*/ /*O*/ /*.*/ /*.*/ /*.*/
0x76, 0x79, 0x38, 0x38, 0x3f, 0x80, 0x80, 0x80,
/* */ /* */ /* */ /* */ /* */ /* */ /* */ /* */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/*H*/ /*E*/ /*L*/ /*L*/ /*O*/ /*.*/ /*.*/ /*.*/
0x76, 0x79, 0x38, 0x38, 0x3f, 0x80, 0x80, 0x80,
};
static uint8_t index = 0;
uint8_t scrollLength = sizeof(scrollText);
sendCommand(0x40);
digitalWrite(strobe, LOW);
shiftOut(data, clock, LSBFIRST, 0xc0);
for (int i = 0; i < 8; i++)
{
uint8_t c = scrollText[(index + i) % scrollLength];
shiftOut(data, clock, LSBFIRST, c);
shiftOut(data, clock, LSBFIRST, c != 0 ? 1 : 0);
}
digitalWrite(strobe, HIGH);
index = ++index % (scrollLength << 1);
return index == 0;
}
void buttons()
{
uint8_t promptText[] =
{
/*P*/ /*r*/ /*E*/ /*S*/ /*S*/ /* */ /* */ /* */
0x73, 0x50, 0x79, 0x6d, 0x6d, 0x00, 0x00, 0x00,
/* */ /* */ /* */ /* */ /* */ /* */ /* */ /* */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/*b*/ /*u*/ /*t*/ /*t*/ /*o*/ /*n*/ /*S*/ /* */
0x7c, 0x1c, 0x78, 0x78, 0x5c, 0x54, 0x6d, 0x00,
/* */ /* */ /* */ /* */ /* */ /* */ /* */ /* */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static uint8_t block = 0;
uint8_t textStartPos = (block / 4) << 3;
for (uint8_t position = 0; position < 8; position++)
{
sendCommand(0x44);
digitalWrite(strobe, LOW);
shiftOut(data, clock, LSBFIRST, 0xC0 + (position << 1));
shiftOut(data, clock, LSBFIRST, promptText[textStartPos + position]);
digitalWrite(strobe, HIGH);
}
block = (block + 1) % 16;
uint8_t buttons = readButtons();
for (uint8_t position = 0; position < 8; position++)
{
uint8_t mask = 0x1 << position;
setLed(buttons & mask ? 1 : 0, position);
}
}
uint8_t readButtons(void)
{
uint8_t buttons = 0;
digitalWrite(strobe, LOW);
shiftOut(data, clock, LSBFIRST, 0x42);
pinMode(data, INPUT);
for (uint8_t i = 0; i < 4; i++)
{
uint8_t v = shiftIn(data, clock, LSBFIRST) << i;
buttons |= v;
}
pinMode(data, OUTPUT);
digitalWrite(strobe, HIGH);
return buttons;
}
void setLed(uint8_t value, uint8_t position)
{
pinMode(data, OUTPUT);
sendCommand(0x44);
digitalWrite(strobe, LOW);
shiftOut(data, clock, LSBFIRST, 0xC1 + (position << 1));
shiftOut(data, clock, LSBFIRST, value);
digitalWrite(strobe, HIGH);
}
Paso 3: Revisión del código
Vamos a repasar el código.
const int strobe = 8; // STB to D8 const int clock = 9; // CLK to D9 const int data = 10; // DIO to D10
strobe, clock y data son constantes que representan los pines conectados a STB, CLK y DIO del módulo de pantalla, respectivamente.
void sendCommand(uint8_t value)
Esta función envía un comando al módulo de pantalla. Pone el pin STB en bajo, envía el byte de comando usando la función shiftOut() y luego pone el pin STB en alto.
void reset()
Esta función reinicia el módulo de pantalla a su estado inicial.
Llama a sendCommand() para activar el modo de auto-incremento y reiniciar la dirección inicial. Luego usa un bucle para enviar 16 bytes con valor 0x00 para limpiar la pantalla.
La función setup() realiza las siguientes tareas una vez:
Configura los modos de los pines STB, CLK y DIO. Llama a sendCommand() para activar la pantalla con brillo máximo. Finalmente, llama a reset() para inicializar la pantalla.
La función loop() se llama repetidamente después de setup(). Es el bucle principal del programa que se ejecuta continuamente. Usa una variable estática mode para seguir el modo actual.
void loop()
Usa una sentencia switch para ejecutar diferentes acciones según el modo actual:
COUNTING_MODE llama a la función counting() e incrementa el modo cuando el contador alcanza una condición específica.
SCROLL_MODE llama a la función scroll() y aumenta el modo cuando el desplazamiento alcanza una condición particular.
BUTTON_MODE llama a la función buttons() para manejar las entradas de botones.
Incluye periodos de retardo entre acciones. Espero que sea útil.
Preguntas frecuentes sobre el controlador de LED TM1638
A continuación encontrarás una lista de las preguntas más frecuentes sobre proyectos construidos con Arduino UNO y el controlador TM1638.
Si tienes otras preguntas, déjalas en la sección de comentarios.
¿Qué es un módulo de pantalla TM1638?
El módulo de pantalla TM1638 es una opción popular para aficionados para conectar pantallas LED, botones y otros periféricos. Integra un controlador de pantalla y un escáner de teclado. Esto facilita controlar e interactuar con varias entradas y salidas.
¿Cómo se comunica el módulo TM1638 con un microcontrolador?
El módulo TM1638 se comunica con un microcontrolador usando un protocolo de comunicación serial simple.
Para enviar y recibir datos se requieren tres líneas de control (datos, reloj y strobe). Consulta la sección de fundamentos en el artículo para entender en detalle el protocolo de comunicación.
¿Cuáles son las principales características del módulo TM1638?
El módulo TM1638 ofrece típicamente ocho pantallas LED de 7 segmentos, un conjunto de indicadores LED y varios botones táctiles. También proporciona control de brillo para la pantalla y soporta multiplexación para reducir los pines I/O necesarios.
¿Puedo controlar varios módulos TM1638 con un solo microcontrolador?
Es posible controlar varios módulos TM1638 con un solo microcontrolador. A cada módulo se le puede asignar una dirección única mediante direccionamiento hardware, permitiendo control individual en una configuración multi-módulo.
¿Qué microcontroladores son compatibles con el módulo TM1638?
El módulo TM1638 puede conectarse con varios microcontroladores, incluyendo populares como Arduino, Raspberry Pi y ESP8266. Mientras el microcontrolador soporte I/O digital y comunicación serial, puede usarse con el módulo.
Un aspecto importante es asegurar la compatibilidad de voltaje entre el microcontrolador y el módulo TM1638.
¿Existen librerías disponibles para programar el módulo TM1638?
Sí, hay varias librerías disponibles para diferentes plataformas y lenguajes de programación que simplifican la integración del módulo TM1638.
Estas librerías proporcionan funciones y abstracciones para controlar la pantalla, leer entradas de botones y manejar otras características del módulo. Consulta la sección de código Arduino para encontrar librerías útiles.
¿Puedo usar el módulo TM1638 para proyectos distintos a la pantalla principal y entrada de botones?
¡Por supuesto! El módulo TM1638 es versátil y puede usarse más allá de la funcionalidad principal de pantalla y botones en muchos proyectos.
Conclusión
Este artículo ha cubierto toda la información esencial sobre el uso del TM1638 con Arduino UNO.
¿Fue fácil de seguir el artículo? Si tienes sugerencias para mejorarlo, siempre eres bienvenido a compartir tus comentarios.
¡Me encantaría saber de ti! Cuéntanos si hay algo más que te gustaría que cubriera en futuros artículos.
