Neste artigo, vou mostrar como funciona o IC driver de LED de 7 segmentos TM1638 e como ligá-lo a um Arduino UNO.
Já usei o IC driver de LED TM1638 em projetos anteriores, pois ele alivia uma enorme carga de trabalho do MCU principal. Adicionar o IC driver de LED ao seu projeto é fácil e simples.
Vou começar por explicar as especificações do driver de LED, partilhar dicas e truques, e mostrar como exibir dígitos e ler os botões.
Depois, entraremos em mais detalhes, analisando o guia de ligação e o código Arduino para a interface paralela de dados LCD do driver TM1638. Também responderemos a perguntas frequentes.
Pegue na sua placa Arduino e vamos começar!
Componentes Necessários Para Construir o Projeto Arduino e TM1638
Componentes de Hardware
- Arduino UNO x 1
- Arduino Compatible TM1638 display module x 1
- Dupont wire x 1 conjunto
- USB Cable for Arduino Programming x 1
Software
Fundamentos do Módulo Driver de LED TM1638
Vamos primeiro entender as principais características do IC driver de LED TM1638:
- Controla 8 dígitos (7 segmentos)
- Controla 8 LEDs
- Lê oito interruptores táteis
- Pode controlar o brilho
- Interface serial – CLK, DIO, STB
A ligação típica entre o Arduino e o IC driver TM1638 está mostrada na imagem abaixo.
Na próxima secção, vamos aprender sobre as interfaces entre vários periféricos e o TM1638.
Detalhes dos pinos do IC driver de LED TM1638
| Nome do pino | Tipo de pino | Descrição do pino |
| DIO | Entrada/saída de dados | Dados seriais entre o Arduino e o IC driver TM1638 |
| STB | Seleção do chip | Inicializa a interface serial durante a borda de descida/subida, depois recebe instrução. O primeiro byte é a instrução quando STB está baixo. CLK é ignorado quando STB está alto. |
| CLK | Entrada de relógio | Entrada de dados seriais |
| K1 ~ K3 | Entrada de dados de varrimento de teclas | Os dados inseridos neste pino são retidos após o ciclo de exibição terminar. |
| SEG1/KS1 ~ SEG8/KS8 | Saída (segmento) | Saída do segmento. Saída open drain. |
| SEG9 ~ SEG10 | Saída (segmento) | Saída do segmento. Saída open drain. |
| GRID1 ~ GRID8 | Saída (grade) | Saída da grade. Saída open drain. |
| VDD | Alimentação lógica | 5 V ± 10% |
| GND | Terra lógico | Conexões à terra |
Uma nota especial sobre o pino DIO: O pino Digital-Input-Output (DIO) no módulo TM1638 é um N-type open drain. Deve ser fornecido um pull-up externo para puxar a linha DIO para nível lógico alto. O valor recomendado é 10 kOhms. Veja o circuito abaixo:
Varrimento de Teclas e Registo de Dados de Varrimento
A taxa de varrimento das teclas é 8 x 3 bits. É semelhante a linhas e colunas. Pode considerar isto como uma matriz de oito linhas por três colunas. Isso significa que pode usar até 24 botões de pressão.
Na imagem abaixo, pode ver como utilizar os pinos K e KS do chip TM1638 para varrer 24 botões
Conjunto de instruções
Pode usar os bits B7 e B6 do bit DIO para decidir o tipo de instrução. O IC TM1638 usa o mecanismo de decodificação abaixo para identificar o tipo de instrução enviada pelo Arduino.
| B7 | B6 | Instrução |
| 0 | 1 | Conjunto de instruções de dados |
| 1 | 0 | Conjunto de instruções de controlo de exibição |
| 1 | 1 | Conjunto de instruções de endereço |
Conjunto de instruções de dados .
Normalmente, usará principalmente o conjunto de instruções de dados. Ele é responsável pela leitura e escrita de dados. Nota: B1 e B0 não devem ser configurados para 01 e 11 para este conjunto de instruções.
| B7 | B6 | B5 | B4 | B3 | B2 | B1 | B0 | Função | Instrução |
| 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | Configuração do modo de escrita de dados | Escrever dados no registo |
| 0 | 1 | 0 | 0 | 0 | 0 | 1 | 0 | Ler dados do varrimento de teclas | |
| 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | Configuração do modo de adição de endereço | Adição automática de endereço |
| 0 | 1 | 0 | 0 | 0 | 1 | 0 | 0 | Endereço fixo | |
| 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | Modo de teste | Modo normal |
| 0 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | Modo de teste |
Nas imagens abaixo, pode ver o padrão de temporização e relógio tanto para escrita como para leitura do IC TM1638.
Note que ao ler dados do chip, deve inserir pelo menos um atraso de 1 us entre a instrução e a receção dos dados. Isto é obrigatório.
Para saber como ligar os pinos do display TM1638 ao display LED de 7 segmentos, consulte a imagem abaixo. O exemplo é para o tipo de cátodo comum. Neste caso, todos os pinos de cátodo dos LEDs estão ligados em conjunto.
Uma alternativa é o tipo de ânodo comum, onde todos os pinos de ânodo dos LEDs estão ligados em conjunto.
É importante conhecer as especificações elétricas do chip com que está a trabalhar. Isso ajuda a depurar e também a garantir que não danifica o chip. Quanto mais souber sobre as especificações do IC, mais fácil será fazer ligações e construir circuitos fiáveis.
Abaixo estão as especificações elétricas do IC driver de LED TM1638:
| Parâmetro | Intervalo |
| Tensão de alimentação lógica | Típico 5 V |
| Tensão de entrada em nível alto | Mínimo 0,7 x VDD |
| Tensão de entrada em nível baixo | Máximo 0,3 x VDD |
| Corrente de saída em nível alto | Máximo 40 mA |
| Corrente de saída em nível baixo | Máximo 140 mA |
| Consumo de corrente ativo | Máximo 5 mA |
| Frequência máxima do relógio | 1 MHz |
| Capacidade de entrada | 15 pF |
Basta de fundamentos ; ) Nas próximas secções, vamos construir o projeto!
Como Ligar o TM1638 ao Arduino UNO
Agora vou mostrar como construir um projeto usando o Arduino UNO e o módulo de display TM1638. Vamos começar pelas ligações de hardware.
Aqui está o resumo das ligações necessárias para conectar o Arduino UNO ao módulo TM1638. Espero que dê uma visão geral das ligações. Siga o guia para a ligação.
| Pino no Módulo TM1638 | Pino do Arduino UNO | Observações |
| VCC | 5 V | Alimentação |
| GND | GND | Conexões à terra |
| STB | Linha de strobe, Pino 8 | Qualquer pino IO |
| CLK | Linha de dados, pino 9 | Qualquer pino IO |
| DIO | Linha de relógio, pino 10 | Qualquer pino IO |
Passo 1: Completar a ligação entre TM1638 e Arduino UNO
Aqui está o diagrama de ligação entre o Arduino UNO e o chip TM1638.
Os dados seriais usam apenas dois fios. Isto ajuda a poupar pinos na placa e também reduz o número de fios.
O protocolo serial usado pelo TM1638 não é um padrão comum. Mas não se preocupe. Existem bibliotecas excelentes que pode usar! Pode encontrar uma dessas bibliotecas here.
Lembre-se sempre de começar pelas conexões à terra. Espere para alimentar o projeto até que todas as ligações estejam feitas.
Passo 2: Programar o código do Arduino UNO abaixo
Siga o próximo passo para entender a implementação do código. Pode usar o código abaixo para testar o módulo TM1638. Não estamos a usar bibliotecas aqui.
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);
}
Passo 3: Análise do Código
Vamos analisar o 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 e data são constantes que representam os PINs ligados aos pinos STB, CLK e DIO do módulo de display, respetivamente.
void sendCommand(uint8_t value)
Esta função envia um comando ao módulo de display. Define o pino STB como baixo, envia o byte de comando usando a shiftOut() função, e depois define o pino STB como alto
void reset()
Esta função reinicia o módulo de display para o seu estado inicial.
Chama sendCommand() para enviar comandos que ativam o modo de incremento automático e reiniciam o endereço inicial. Depois usa um ciclo para enviar 16 bytes com valor 0x00 para limpar o display.
A função setup() executa as seguintes tarefas uma vez:
Define os modos dos pinos STB, CLK e DIO. Chama sendCommand() para ativar o display com brilho máximo. Finalmente, chama reset() para inicializar o display.
A função loop() é chamada repetidamente após a função setup(). A função loop() é o ciclo principal do programa que corre continuamente. Usa uma variável estática mode para acompanhar o modo atual.
void loop()
Usa uma instrução switch para executar ações diferentes com base no modo atual:
COUNTING_MODE chama a counting() função e incrementa o modo quando o contador atinge uma condição específica.
SCROLL_MODE chama a scroll() função e incrementa o modo quando a rolagem atinge uma condição particular.
BUTTON_MODE chama a buttons() função para tratar as entradas dos botões.
Inclui períodos de atraso entre as ações. Espero que ajude.
Perguntas Frequentes Sobre o IC Driver de LED TM1638
Abaixo encontra uma lista das perguntas mais frequentes sobre projetos construídos usando o Arduino UNO e o IC driver de LED TM1638.
Se tiver outras perguntas, deixe-as na secção de comentários.
O que é um módulo de display TM1638?
O módulo de display TM1638 é uma opção popular para entusiastas que querem interligar displays LED, botões e outros periféricos. Integra um controlador de display e um scanner de teclado. Isto facilita o controlo e a interação com várias entradas e saídas.
Como comunica o módulo de display TM1638 com um microcontrolador?
O módulo TM1638 comunica com um microcontrolador usando um protocolo simples de comunicação serial.
Para enviar e receber dados são necessárias três linhas de controlo (dados, relógio e strobe). Consulte a secção de fundamentos no artigo para entender detalhadamente o protocolo de comunicação.
Quais são as principais características do módulo de display TM1638?
O módulo TM1638 oferece tipicamente oito displays LED de 7 segmentos, um conjunto de indicadores LED e vários botões táteis. Também fornece controlo de brilho para o display e suporta multiplexação para reduzir os pinos I/O necessários.
Posso controlar vários módulos TM1638 com um único microcontrolador?
É possível controlar vários módulos TM1638 com um único microcontrolador. Cada módulo pode ser atribuído a um endereço único através de endereçamento por hardware, permitindo o controlo individual numa configuração multi-módulo.
Quais microcontroladores são compatíveis com o módulo de display TM1638?
O módulo TM1638 pode ser interligado com vários microcontroladores, incluindo populares como Arduino, Raspberry Pi e ESP8266. Desde que o microcontrolador suporte I/O digital e comunicação serial, pode ser usado com o módulo.
Um aspeto importante é garantir a compatibilidade de tensão entre o microcontrolador e o módulo TM1638.
Existem bibliotecas disponíveis para programar o módulo de display TM1638?
Sim, existem várias bibliotecas disponíveis para diferentes plataformas e linguagens de programação para simplificar a integração do módulo TM1638.
Estas bibliotecas fornecem funções e abstrações para controlar o display, ler entradas dos botões e gerir outras funcionalidades do módulo. Consulte a secção Código Arduino para encontrar bibliotecas úteis.
Posso usar o módulo de display TM1638 para projetos além do display principal e entrada de botões?
Claro! O módulo TM1638 é versátil e pode ser usado para além da funcionalidade principal de display e botões em muitos projetos.
Conclusão
Este artigo cobriu toda a informação essencial sobre o uso do TM1638 com o Arduino UNO.
O artigo foi fácil de seguir? Se tiver sugestões para melhorar o artigo, está sempre convidado a partilhar o seu feedback.
Gostaria muito de ouvir a sua opinião! Diga-nos se há algo mais que gostaria que eu abordasse em futuros artigos.
