Neste tutorial, vais aprender como controlar displays TM1637 de 4 dígitos e 7 segmentos com Arduino. Estes displays são fantásticos para mostrar dados de sensores, temperatura, hora, etc.
Incluí 3 exemplos neste tutorial. No primeiro exemplo, vamos ver as funções básicas da biblioteca TM1637Display. No segundo exemplo, vou mostrar como podes exibir a hora num display de 4 dígitos. O último exemplo pode ser usado para criar um simples display de temperatura em combinação com o DHT11.
Materiais necessários
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.
Informações sobre o display
Displays 7 segmentos de 4 dígitos simples normalmente requerem 12 pinos de ligação. Isso é bastante e não deixa muito espaço para outros sensores ou módulos. Graças ao IC TM1637 montado na parte traseira do módulo do display, este número pode ser reduzido para apenas quatro. Dois pinos são necessários para as ligações de energia e os outros dois para controlar os segmentos.
Displays 7 segmentos contêm 7 (ou 8) LEDs individualmente endereçáveis. Os segmentos são rotulados de A a G e alguns displays também têm um ponto (o 8º LED). Usa esta imagem como referência ao configurar os segmentos individuais no código mais tarde.
Podes comprar muitos módulos de display diferentes que usam um IC TM1637. A cor, tamanho, pontos e pontos de ligação podem variar. Não tenho experiência com todas as versões deste display, mas desde que usem o TM1637, os exemplos de código fornecidos abaixo deverão funcionar.
Aqui podes encontrar as especificações básicas do módulo de display que usei neste tutorial.
Especificações do Display TM1637 4 Dígitos 7 Segmentos
| Tensão de funcionamento | 3.3 – 5 V |
| Consumo de corrente | 80 mA |
| Níveis de luminância | 8 |
| Dimensões do display | 30 x 14 mm (dígitos de 0,36″) |
| Dimensões totais | 42 x 24 x 12 mm |
| Dimensões dos furos | 38 x 20, ⌀ 2,2 mm |
| Temperatura de funcionamento | -10 – 80 °C |
| Custo | Check price |
O IC TM1637 é fabricado por Titan Micro Electronics. Para mais informações, podes consultar o datasheet abaixo:
Ligação – Como ligar o display TM1637 4 dígitos 7 segmentos ao Arduino UNO
Ligar o display a um Arduino ou outro microcontrolador é muito fácil. Só precisas de ligar 4 fios: 2 para energia e 2 para transferir os dados.
O diagrama de ligação abaixo mostra como podes ligar o display ao Arduino.
As ligações também estão indicadas na tabela abaixo:
Ligações do Display TM1637
| Display TM1637 4 Dígitos | Arduino |
|---|---|
| VCC | 5 V |
| GND | GND |
| CLK | Pino digital 2 |
| DIO | Pino digital 3 |
Note que a ordem e localização dos pinos pode variar dependendo do fabricante!
Para este tutorial, liguei CLK e DIO aos pinos 2 e 3 respetivamente, mas podes mudar para qualquer pino digital que queiras. Só tens de alterar a configuração dos pinos no código em conformidade.
Exemplo de código Arduino para display TM1637 4 dígitos 7 segmentos
Avishay Orpaz escreveu uma excelente biblioteca para displays TM1637, a TM1637Display library. Esta biblioteca tem várias funções integradas que tornam o controlo do display bastante fácil.
As funções principais incluem:
- setSegments() – Define o valor bruto dos segmentos de cada dígito
- showNumberDec() – Exibe um número decimal
- showNumberDecEx() – Exibe um número decimal com pontos decimais ou dois pontos
- setBrightness() – Define o brilho do display
- clear() – Limpa o display
O exemplo de código abaixo inclui todas estas funções. Vou explicar como cada função pode ser usada em mais detalhe abaixo.
Podes carregar o código de exemplo para o teu Arduino usando o Arduino IDE.
Para instalar a biblioteca, podes descarregá-la como um .zip a partir de Github. Depois, vai a Sketch > Include Library > Add .ZIP Library… no Arduino IDE.
Outra opção é navegar até Tools > Manage Libraries… ou pressionar Ctrl + Shift + I no Windows. O Gestor de Bibliotecas abrirá e atualizará a lista de bibliotecas instaladas.
Podes procurar por ‘tm1637’ e procurar a biblioteca do Avishay Orpaz. Seleciona a versão mais recente e depois clica em Install.
Exemplo de código
Podes copiar o código clicando no botão no canto superior direito do 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);
}
Como o código funciona:
O código começa por incluir a biblioteca. Certifica-te de que tens a biblioteca correta instalada, caso contrário receberás uma mensagem de erro ao compilar o código.
// Include the library: #include "TM1637Display.h"
O passo seguinte é especificar os pinos de ligação. A instrução #define é usada para dar um nome a um valor constante. O compilador substituirá qualquer referência a esta constante pelo valor definido quando o programa for compilado. Assim, em todo o lado onde menciones CLK, o compilador substituirá pelo valor 2 quando o programa for compilado.
// Define the connections pins: #define CLK 2 #define DIO 3
Iniciar Display
De seguida, criamos um objeto display do tipo TM1637Display com os pinos CLK e DIO definidos. Nota que chamei o display ‘display’, mas podes usar outros nomes como ‘temperature_display’.
O nome que dás ao display será usado mais tarde para escrever dados nesse display em particular. Podes criar e controlar múltiplos objetos display com nomes e pinos de ligação diferentes. Atualmente não há limite na 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);
Existem várias formas de controlar os segmentos individuais do display. Antes da secção setup do código, especifiquei vários arrays para definir os segmentos individuais do display. Usaremos a função setSegments() mais tarde para os escrever no display.
A primeira opção é escrever números hexadecimais no display para cada dígito. O hexadecimal 0xff traduz-se em 11111111 em binário, isto ativa todos os segmentos (incluindo o ponto se o teu display tiver). 0xef, por exemplo, traduz-se em 11101111. Isto ativaria todos os segmentos, exceto o segmento E. Nota que a contagem vai da direita para a esquerda, por isso 11111111 corresponde aos segmentos (ponto)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};
A biblioteca tem uma função integrada que torna a definição dos segmentos individuais um pouco mais fácil. Vê o trecho de código abaixo. Podes criar arrays para soletrar palavras. Cada segmento é separado por um | e os dígitos do display são separados por vírgula.
// 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
};
Função Setup
Podes deixar a secção setup do código vazia se quiseres. Eu apenas usei a função clear() para garantir que o display foi limpo.
void setup() {
// Clear the display:
display.clear();
delay(1000);
}
Função Loop
Na secção 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 é o array que inclui a informação dos segmentos. O segundo argumento especifica o número de dígitos a modificar (0-4). Se quiseres 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). Por isso, se quiseres imprimir um símbolo °C no terceiro e quarto dígito, usarias:
// 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);
O segundo e terceiro argumento da função também podem ser omitidos.
showNumberDec(number, leading_zeros, length, position)
Esta é provavelmente a função que vais usar mais. O primeiro argumento é um número que queres mostrar no ecrã. Os restantes argumentos são opcionais.
O segundo argumento pode ser usado para ativar ou desativar zeros à esquerda. 10 sem zeros à esquerda seria mostrado como __10 e com zeros à esquerda como 0010. Podes ativá-los definindo este argumento como true ou desativá-los definindo como false. NOTA: zeros à esquerda não são suportados com números negativos.
O terceiro e quarto argumento são iguais aos da função 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 função permite controlar os pontos do display. Apenas o segundo argumento é diferente da função showNumberDec. Permite definir os pontos entre os dígitos individuais.
Podes usar os seguintes valores.
Para displays com pontos entre cada dígito usa
- 0b10000000 – 0.000
- 0b01000000 – 00.00
- 0b00100000 – 000.0
- 0b11100000 – 0.0.0.0
para displays com apenas dois pontos usa
- 0b01000000 – 00:00
e para displays com pontos e dois pontos usa
- 0b11100000 – 0.0:0.0
Por isso, se quiseres mostrar um relógio com dois pontos centrais ligados (ver exemplo do relógio abaixo), usarias algo como:
// Print 1234 with the center colon: display.showNumberDecEx(1234, 0b11100000, false, 4, 0);
setBrightness(brightness, true/false)
Esta função define o brilho do display (como o nome indica). Podes 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, false significa desligado.
// Set the display brightness (0-7): display.setBrightness(7);
Exemplo de relógio: display TM1637 4 dígitos 7 segmentos com DS3231 RTC
Um dos usos típicos para um display 7 segmentos de 4 dígitos é mostrar a hora. Combinando o TM1637 com um módulo de relógio em tempo real (RTC), podes facilmente criar um relógio de 24 horas.
Neste exemplo usei este popular DS3231 RTC module. Este módulo comunica com o Arduino via I2C, por isso só precisas de duas ligações para ler a hora.
O diagrama de ligação abaixo mostra como podes ligar o DS3231 RTC ao Arduino. Nota que o display TM1637 está ligado da mesma forma que antes.
As ligações também estão indicadas na tabela abaixo:
Ligações do DS3231 RTC
| DS3231 | Arduino |
|---|---|
| VCC | 5 V |
| GND | GND |
| SDA | A4 |
| SCL | A5 |
O exemplo de código seguinte pode ser usado para mostrar a hora em formato 24 horas. Se o teu display tiver um dois pontos central, este código fará com que ele pisque. Também podes desativar isso removendo as últimas linhas do código.
Na primeira vez que carregares o código, o RTC será definido para a hora em que o sketch foi compilado.
Podes instalar uma bateria de célula de moeda na parte traseira do módulo, para que a hora seja guardada caso perca energia. Aparentemente, o circuito de carregamento da maioria dos módulos chineses pode possivelmente sobrecarregar a bateria de célula de moeda (link), por isso talvez queiras comprar uma DS3231 module da Adafruit em vez disso.
O código usa a biblioteca Adafruit RTC, que podes descarregar em GitHub. Também podes instalá-la via o Gestor de Bibliotecas no Arduino IDE procurando por “RTClib”, ou clicar no botão de download abaixo:
Exemplo de código
/* 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);
}
Exemplo de termómetro: display TM1637 4 dígitos 7 segmentos com sensor de temperatura e humidade DHT11
Displays 7 segmentos de 4 dígitos são ótimos para mostrar leituras de sensores como temperatura, humidade, voltagem ou velocidade. No exemplo seguinte, vou mostrar como podes exibir leituras de temperatura no display TM1637.
Vamos usar o popular DHT11 sensor de temperatura e humidade. O diagrama de ligação abaixo mostra como podes ligar o sensor DHT11 em combinação com o display TM1637 ao Arduino.
Nota que o display TM1637 está ligado da mesma forma que antes.
As ligações também estão indicadas na tabela abaixo:
Ligações do DHT11
| DHT11 | Arduino |
|---|---|
| + | 5 V |
| – | GND |
| s | Pino digital 4 |
Nota que a ordem dos pinos pode ser diferente, dependendo do fabricante.
Se quiseres usar um sensor de 4 pinos, vê o meu tutorial para os sensores de temperatura e humidade DHT11 e DHT22: How to use DHT11 and DHT22 Sensors with Arduino.
O código de exemplo abaixo pode ser usado para mostrar as leituras de temperatura no display. Alterna entre a temperatura em Celsius e Fahrenheit, ambos mostrados por 2 segundos.
A função setSegments() é usada para mostrar os símbolos Celsius e Fahrenheit.
O código usa a biblioteca Adafruit DHT sensor que podes descarregar em GitHub. Esta biblioteca só funciona se também tiveres instalada a biblioteca Adafruit Unified Sensor, que também está disponível em GitHub.
Podes também descarregar as duas bibliotecas clicando nos botões abaixo:
Exemplo de código
/* 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);
}
Conclusão
Neste artigo mostrei como podes usar um display TM1637 4 dígitos 7 segmentos com Arduino. Também vimos um exemplo de relógio e termómetro.
Para mais tutoriais sobre displays, vê os nossos How to control a character I2C LCD with Arduino e How to use a 16×2 character LCD with Arduino tutoriais.
Se tiveres alguma dúvida, deixa um comentário abaixo.
