Guia de como usar o display LED de 7 segmentos com 4 dígitos TM1637 no Arduino

Tempo de leitura: 13 minutes

Neste guia, você aprenderá como controlar as telas TM1637 de 4 dígitos e 7 segmentos com o Arduino. Essas exibições são fantásticas para exibir dados do sensor, temperatura, tempo, etc.

Eu incluí 3 exemplos neste guia. No primeiro exemplo, veremos as funções básicas da biblioteca TM1637Display. No segundo exemplo, vou mostrar como você pode exibir a hora em um display de 4 dígitos. O último exemplo pode ser usado para criar uma exibição de temperatura simples em combinação com o DHT11 e ou DHT22.

Diagramas de ligação também estão incluídos. Após o exemplo, eu analiso e explico como o código funciona, então você não deve ter problemas para modificá-lo para atender às suas necessidades.

Se você tiver alguma dúvida, deixe um comentário abaixo.

Para obter mais tutoriais de exibição, confira os artigos abaixo:

 

Suprimentos

Componentes de hardware

TM1637 TM1637 Display de 4 dígitos e 7 segmentos × 1
Arduino Uno Rev 3 × 1
ProtoBoard × 1
Fios de jumpers ~ 10
DS3231 RTC × 1
Adafruit DS3231 Precision RTC Breakout (alternativa) × 1
Sensor de temperatura e umidade DHT11 (3 pinos) × 1
Cabo USB tipo A/B

 

Informações sobre o display

Os visores nus de 4 dígitos e 7 segmentos geralmente requerem 12 pinos de conexão. Isso é bastante e não deixa muito espaço para outros sensores ou módulos. Graças ao TM1637 IC montado na parte traseira do módulo de exibição, esse número pode ser reduzido para apenas quatro. Dois pinos são necessários para as conexões de alimentação e os outros dois pinos são usados para controlar os segmentos.

Os visores de 7 segmentos contêm 7 (ou 8) LEDs endereçáveis individualmente. Os segmentos são rotulados de A a G e alguns visores também têm um ponto (o 8º LED). Use essa imagem como referência ao definir os segmentos individuais no código posteriormente.

Você pode comprar muitos módulos de exibição diferentes que usam um TM1637 IC. A cor, tamanho, pontos e pontos de conexão podem ser diferentes. Não tenho experiência com todas as diferentes versões deste monitor, mas contanto que eles usem o TM1637, os exemplos de código fornecidos abaixo devem funcionar.

Aqui você pode encontrar as especificações básicas do módulo de exibição que usei neste tutorial.

Especificações do display de 4 dígitos e 7 segmentos TM1637

Tensão operacional 3.3 – 5 V
Corrente de Exibição 80 mA
Níveis de luminância 8
Dimensões de exibição 30 x 14 mm (0.36″ digits)
Dimensão total 42 x 24 x 12 mm
Dimensões do furo 38 x 20, ⌀ 2.2 mm
Temperatura de operação -10 – 80 °C
Custo Aproximado de 14 a 20R$

O TM1637 IC é fabricado pela Titan Micro Electronics. Para mais informações, você pode verificar o datasheet aqui:

 

Conectando o monitor TM1637 de 4 dígitos e 7 segmentos ao Arduino UNO

Conectar o monitor a um Arduino ou outro microcontrolador é muito fácil. Você só precisa conectar 4 fios: 2 para alimentação e 2 para transferir os dados.

O diagrama de ligação abaixo mostra como você pode conectar o monitor ao Arduino.

TM1637 Display de 4 dígitos e 7 segmentos com diagrama de ligação Arduino UNO.

 

As conexões também são fornecidas na tabela abaixo:

Conexões do monitor TM1637

TM1637 Display de 4 dígitos Arduino
VCC 5 V
GND GND
CLK Digital pino 2
DIO Digital pino 3

Observe que a ordem e a localização dos pinos podem ser diferentes dependendo do fabricante!

Para este guia, conectei CLK e DIO aos pinos 2 e 3 respectivamente, mas você pode alterar isso para qualquer um dos pinos digitais que desejar. Você apenas precisa alterar a configuração do pino no código de acordo.

 

Código de exemplo Arduino de display de 4 dígitos e 7 segmentos TM1637

Avishay Orpaz escreveu uma excelente biblioteca para monitores TM1637, a biblioteca TM1637Display. Esta biblioteca possui várias funções integradas que tornam o controle da tela bastante fácil.

As principais funções incluem:

  • setSegments() – Defina o valor bruto dos segmentos de cada dígito
  • showNumberDec() – Exibir um número decimal
  • showNumberDecEx() – Mostra um número decimal com casas decimais ou dois pontos
  • setBrightness() – Defina o brilho da tela
  • clear() – Limpar a tela

O exemplo de código a seguir apresenta todas essas funções. Vou explicar como cada função pode ser usada com mais detalhes abaixo.

Você pode fazer upload do código de exemplo para o seu Arduino usando o IDE do Arduino.

Para instalar a biblioteca, você pode baixá-la como um arquivo .zip do GitHub aqui. Em seguida, vá para Sketch > Include Library > Add .ZIP Library… no IDE do Arduino.

Outra opção é navegar para Tools > Manage Libraries… ou digite Ctrl + Shift + I no Windows. O Library Manager irá abrir e atualizar a lista de bibliotecas instaladas.

Você pode pesquisar por ‘tm1637’ e procurar a biblioteca de Avishay Orpaz. Selecione a versão mais recente e clique em Instalar.

 

Código de exemplo

Você pode copiar o código clicando no botão no canto superior direito do campo do código.

/* Example code for TM1637 4 digit 7 segment display with Arduino. */
// Incluir a biblioteca:
#include <TM1637Display.h>
// Defina os pinos de conexão:
#define CLK 2
#define DIO 3
// Criar objeto de exibição do tipo TM1637Display:
TM1637Display display = TM1637Display(CLK, DIO);
// Crie uma matriz que ativa todos os segmentos:
const uint8_t data[] = {0xff, 0xff, 0xff, 0xff};
// Crie uma matriz que desativa todos os segmentos:
const uint8_t blank[] = {0x00, 0x00, 0x00, 0x00};
// Você pode definir os segmentos individuais por dígito para soletrar palavras ou criar outros símbolos:
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
};
// Cria o símbolo de graus Celsius:
const uint8_t celsius[] = {
  SEG_A | SEG_B | SEG_F | SEG_G,  // Circle
  SEG_A | SEG_D | SEG_E | SEG_F   // C
};
void setup() {
  // Limpe a tela:
  display.clear();
  delay(1000);
}
void loop() {
  // Defina o brilho:
  display.setBrightness(7);
  // Todos os segmentos em:
  display.setSegments(data);
  delay(1000);
  display.clear();
  delay(1000);
  // Mostrar contador:
  int i;
  for (i = 0; i < 101; i++) {
    display.showNumberDec(i);
    delay(50);
  }
  delay(1000);
  display.clear();
  delay(1000);
  // Imprime o número em locais diferentes, faz 2 loops:
  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);
  // Definir brilho (0-7):
  int k;
  for (k = 0; k < 8; k++) {
    display.setBrightness(k);
    display.setSegments(data);
    delay(500);
  }
  delay(1000);
  display.clear();
  delay(1000);
  // Imprime 1234 com os dois pontos centrais:
  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);
}

 

Como funciona o código:

O código começa com a inclusão da biblioteca. Certifique-se de que a biblioteca correta esteja instalada, caso contrário, você receberá uma mensagem de erro ao compilar o código.

// Incluir a biblioteca:
#include <TM1637Display

A próxima etapa é especificar os pinos de conexão. A instrução #define é usada para dar um nome a um valor constante. O compilador substituirá todas as referências a esta constante pelo valor definido quando o programa for compilado. Portanto, sempre que você mencionar CLK, o compilador o substituirá pelo valor 2 quando o programa for compilado.

// Defina os pinos de conexão:
#define CLK 2
#define DIO 3

Em seguida, criamos um objeto de exibição do tipo TM1637Display com os pinos CLK e DIO definidos. Observe que chamei o display de ‘display’, mas você também pode usar outros nomes, como ‘temperatura_display’.

O nome que você der ao display será usado posteriormente para gravar dados naquele display específico. Você pode criar e controlar vários objetos de exibição com diferentes nomes e pinos de conexão. Atualmente não há limite na biblioteca.

// Criar objeto de exibição do tipo TM1637Display:
TM1637Display display = TM1637Display(CLK, DIO);
// Você pode criar mais de um objeto de exibição. Dê a eles nomes e pinos de conexão diferentes:
TM1637Display display_1  = TM1637Display(2, 3);
TM1637Display display_2  = TM1637Display(4, 5);
TM1637Display display_3  = TM1637Display(6, 7);

Existem várias maneiras de controlar os segmentos individuais da tela. Antes da seção de configuração do código, especifiquei vários arrays para definir os segmentos de exibição individuais. Usaremos a função setSegments() mais tarde para gravá-los no display.

A primeira opção é escrever números hexadecimais no visor para cada dígito. O hexadecimal 0xff se traduz em 11111111 em binário, isso ativa todos os segmentos (incluindo o ponto se o seu monitor tiver um). 0xef, por exemplo, se traduz em 11101111. Isso ativaria todos os segmentos, exceto o segmento E. Observe que a contagem vai da direita para a esquerda, então 11111111 corresponde aos segmentos (ponto) GFEDCBA. Você pode encontrar um gráfico de conversão de hexadecimal para binário aqui.

// Crie uma matriz que ativa todos os segmentos:
const uint8_t data[] = {0xff, 0xff, 0xff, 0xff};
// Crie uma matriz que desativa todos os segmentos:
const uint8_t blank[] = {0x00, 0x00, 0x00, 0x00};

A biblioteca possui uma função integrada que torna a configuração de segmentos individuais um pouco mais fácil. Veja o snippet de código abaixo. Você pode criar matrizes para soletrar palavras. Cada segmento é separado por um | e os dígitos do display são separados por uma vírgula.

// Você pode definir os segmentos individuais por dígito para soletrar palavras ou criar outros símbolos:
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
};

Você pode deixar a seção de configuração do código em branco, se desejar. Acabei de usar a função clear() para garantir que o display foi apagado.

void setup() {
  // Limpar a tela:
  display.clear();
  delay(1000);
}

Na seção de loop do código, mostro vários exemplos das diferentes funções da biblioteca:

 

setSegments(segments[ ], length, position)

Esta função pode ser usada para definir os segmentos individuais do display. O primeiro argumento é a matriz que inclui as informações do segmento. O segundo argumento especifica o número de dígitos a serem modificados (0-4). Se você quiser soletrar dOnE, seria 4; para um símbolo °C, seria 2. O terceiro argumento define a posição a partir da qual imprimir (0 – mais à esquerda, 3 – mais à direita). Portanto, se você quiser imprimir um símbolo °C no terceiro e quarto dígitos, você deve usar:

// Cria o símbolo de graus Celsius:
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);

O segundo e o terceiro argumento da função também podem ser omitidos.

 

showNumberDec(number, leading_zeros, length, position)

Esta é provavelmente a função que você mais usará. O primeiro argumento é um número que você deseja exibir na tela. O resto dos argumentos são opcionais.

O segundo argumento pode ser usado para ativar ou desativar zeros à esquerda. 10 sem zeros à esquerda seria impresso como __10 e com zeros à esquerda como 0010. Você pode ativá-los definindo este argumento como verdadeiro ou desativá-los definindo-o como falso. NOTA: zero à esquerda não é compatível com números negativos.

O terceiro e o quarto argumento são iguais aos da função anterior.

// Imprime o número 12 sem zeros à esquerda no segundo e terceiro dígitos:
display.showNumberDec(12, false, 2, 1);

 

showNumberDecEx(number, dots, leading_zeros, length, position)

Esta função permite controlar os pontos da tela. Apenas o segundo argumento é diferente da função showNumberDec. Ele permite que você defina os pontos entre os dígitos individuais.

Você pode usar os seguintes valores.

Para telas com pontos entre cada dígito:

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

Para monitores com apenas dois pontos:

  • 0b01000000 – 00:00

Para telas com pontos e dois-pontos:

  • 0b11100000 – 0.0:0.0

Portanto, se você quiser exibir um relógio com dois pontos centrais (veja o exemplo de relógio abaixo), você deve usar algo como:

// Imprime 1234 com os dois pontos centrais:
display.showNumberDecEx(1234, 0b11100000, false, 4, 0);

 

setBrightness(brightness, true/false)

Esta função define o brilho do display (como o nome sugere). Você pode especificar um nível de brilho de 0 (brilho mais baixo) a 7 (brilho mais alto). O segundo parâmetro pode ser usado para ligar ou desligar o display, falso significa desligado.

// Defina o brilho da tela (0-7):
display.setBrightness(7);

 

Exemplo de relógio: TM1637 display de 7 segmentos de 4 dígitos com DS3231 RTC

Um dos usos típicos de um display de 7 segmentos de 4 dígitos é mostrar a hora. Combinando o TM1637 com um módulo de relógio em tempo real (RTC), você pode criar facilmente um relógio de 24 horas.

Neste exemplo, usei este módulo DS3231 RTC comumente usado.

Este módulo se comunica com o Arduino via I2C, então você só precisa de duas conexões para ler a hora.

O diagrama de fiação abaixo mostra como você pode conectar o DS3231 RTC ao Arduino. Observe que o display TM1637 está conectado da mesma forma que antes.

TM1637 com diagrama de ligação DS3231 RTC e Arduino UNO.

 

As conexões também são fornecidas na tabela abaixo:

Conexões DS3231 RTC

DS3231 Arduino
VCC 5 V
GND GND
SDA A4
SCL A5

O exemplo de código a seguir pode ser usado para exibir a hora em um formato de 24 horas. Se o seu visor tiver dois pontos centrais, este código o fará piscar. Você também pode desabilitar isso removendo as últimas linhas de código.

Na primeira vez que você carregar o código, o RTC será definido para a hora em que o esboço foi compilado.

Você pode instalar uma bateria de célula tipo moeda na parte traseira do módulo, de forma que o tempo seja armazenado no caso de perda de energia. Aparentemente, o circuito de carga da maioria dos módulos chineses pode sobrecarregar a bateria de célula tipo moeda, então você pode querer comprar um módulo DS3231 da Adafruit.

O código usa a biblioteca Adafruit RTC, que você pode baixar aqui no GitHub. Você também pode instalá-lo por meio do Library Manager no Arduino IDE procurando por ‘RTClib’ :

 

Código de exemplo

/* Código de exemplo do Arduino para exibir um formato de relógio de 24 horas em um display TM1637 de 4 dígitos e 7 segmentos com um DS32321 RTC.*/
// Incluir as bibliotecas:
#include "RTClib.h"
#include <TM1637Display.h>
// Defina os pinos de conexão:
#define CLK 2
#define DIO 3
// Criar rtc e objeto de exibição:
RTC_DS3231 rtc;
TM1637Display display = TM1637Display(CLK, DIO);
void setup() {
  // Comece a comunicação serial a uma taxa de transmissão de 9600:
  Serial.begin(9600);
  // Aguarde a abertura do console:
  delay(3000);
  // Verifique se o RTC está conectado corretamente:
  if (! rtc.begin()) {
    Serial.println("Não foi possível encontrar RTC");
    while (1);
  }
  // Verifique se o RTC perdeu energia e, em caso afirmativo, defina a hora:
  if (rtc.lostPower()) {
    Serial.println("RTC perdeu energia, vamos definir a hora!");
    // A linha a seguir define o RTC para a data e hora em que este sketch foi compilado:
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
    // Esta linha define o RTC com uma data e hora explícitas, por exemplo, para definir
    // 21 de janeiro de 2014 às 3h, você ligaria:
    //rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));
  }
  // Defina o brilho da tela (0-7):
  display.setBrightness(5);
  // Limpe a tela:
  display.clear();
}
void loop() {
  // Obtenha a data e hora atuais:
  DateTime now = rtc.now();
  // Crie um formato de hora para exibir:
  int displaytime = (now.hour() * 100) + now.minute();
  // Imprime o tempo de exibição no Monitor Serial:
  Serial.println(displaytime);
  // Exibe a hora atual no formato de 24 horas com zeros à esquerda habilitados e dois pontos centrais:
  display.showNumberDecEx(displaytime, 0b11100000, true);
  // Remova as seguintes linhas de código se quiser uma estática em vez de dois pontos centrais piscando:
  delay(1000);
  display.showNumberDec(displaytime, true); // Imprime o tempo de exibição sem dois pontos centrais.
  delay(1000);
}

 

Exemplo de termômetro: TM1637 display de 7 segmentos de 4 dígitos com sensor de temperatura e umidade DHT11

Os visores de 7 segmentos de 4 dígitos são ótimos para exibir leituras de sensores como temperatura, umidade, tensão ou velocidade. No exemplo a seguir, vou mostrar como você pode exibir leituras de temperatura no visor TM1637.

Estaremos usando o popular sensor de temperatura e umidade DHT11.

O diagrama de ligação abaixo mostra como você pode conectar o sensor DHT11 em combinação com o monitor TM1637 ao Arduino.

Observe que o display TM1637 está conectado da mesma forma que antes.

TM1637 Display de 4 dígitos e 7 segmentos com sensor de temperatura e umidade DHT11 e diagrama de ligação Arduino UNO.

As conexões também são fornecidas na tabela abaixo:

Conexões DHT11

DHT11 Arduino
+ 5 V
GND
s Digital pino 4

Observe que a ordem dos pinos pode ser diferente, dependendo do fabricante.

Se você gostaria de usar um sensor de 4 pinos, verifique meu tutorial para os sensores de temperatura e umidade DHT11 e DHT22.

Guia completo para o sensor de umidade e temperatura DHT11/DHT22 com Arduino

O código de exemplo abaixo pode ser usado para exibir as leituras de temperatura no display. Ela alterna entre a temperatura em Celsius e Fahrenheit, ambas exibidas por 2 segundos.

A função setSegments() é usada para exibir os símbolos Celsius e Fahrenheit.

O código usa a biblioteca de sensores Adafruit DHT, que você pode baixar aqui no GitHub. Esta biblioteca só funciona se você também tiver a biblioteca Adafruit Unified Sensor instalada, que também está disponível no GitHub.

Código de exemplo

/* Esboço de exemplo do Arduino para exibir leituras de temperatura DHT11 em um display TM1637 de 4 dígitos e 7 segmentos. */
// Incluir as bibliotecas:
#include <TM1637Display.h>
#include <Adafruit_Sensor.h>
#include <DHT.h>
// Defina os pinos de conexão:
#define CLK 2
#define DIO 3
#define DHTPIN 4
// Criar variável:
int temperature_celsius;
int temperature_fahrenheit;
// Cria o símbolo de graus Celsius:
const uint8_t celsius[] = {
  SEG_A | SEG_B | SEG_F | SEG_G,  // Circle
  SEG_A | SEG_D | SEG_E | SEG_F   // C
};
// Criar símbolo de grau Fahrenheit:
const uint8_t fahrenheit[] = {
  SEG_A | SEG_B | SEG_F | SEG_G,  // Circle
  SEG_A | SEG_E | SEG_F | SEG_G   // F
};
// Defina o tipo DHT, descomente qualquer tipo que você está usando!
#define DHTTYPE DHT11   // DHT 11 
//#define DHTTYPE DHT22   // DHT 22  (AM2302)
//#define DHTTYPE DHT21   // DHT 21 (AM2301)
// Criar objeto de exibição do tipo TM1637Display:
TM1637Display display = TM1637Display(CLK, DIO);
// Criar objeto dht do tipo DHT:
DHT dht = DHT(DHTPIN, DHTTYPE);
void setup() {
  // Defina o brilho da tela (0-7):
  display.setBrightness(0);
  // Limpe a tela:
  display.clear();
  // Configuração do sensor:
  dht.begin();
  // Comece a comunicação serial a uma taxa de transmissão de 9600:
  Serial.begin(9600);
  // Aguarde a abertura do console:
  delay(2000);
}
void loop() {
  // Leia a temperatura em graus Celsius e Fahrenheit:
  temperature_celsius = dht.readTemperature();
  temperature_fahrenheit = dht.readTemperature(true);
  // Imprima a temperatura no Monitor Serial:
  Serial.println(temperature_celsius);
  Serial.println(temperature_fahrenheit);
  // Mostra a temperatura no display TM1637:
  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);
}

 

 

Conclusão

Neste guia, mostrei como você pode usar um display TM1637 de 4 dígitos e 7 segmentos com o Arduino. Também vimos um exemplo de relógio e termômetro. Espero que você tenha achado útil e informativo. Se sim, compartilhe com um amigo que também gosta de eletrônicos e de fazer coisas!

Eu realmente gosto de usar essas telas para mostrar as leituras dos sensores ou coisas como a velocidade de um motor. Com a biblioteca TM1637Display, programar os visores torna-se muito fácil, então não há razão para você não incorporar um em seu próximo projeto.

Eu adoraria saber quais projetos você planeja construir (ou já construiu) com este monitor. Se você tiver alguma dúvida, sugestão, ou se achar que falta alguma coisa neste tutorial, por favor, deixe um comentário abaixo.

Visits: 3 Visits: 1199100