Nesse Guia completo dos Displays de 7 segmentos – Arduino, você aprenderá como funcionam os Displays de 7 segmentos e métodos de controle dos mesmos. Terá instruções de como fazer as montagens de alguns tipos de displays mais comuns, usando o Arduino. Esses são os tópicos desse Tutorial :
O princípio de funcionamento de obtenção de luz à partir da emissão de fótons de cristais semicondutores foi descoberto no início do século XX .
O LED (light emitting diode) ou diodo emissor de luz, apesar de ter sido criado no início da década de 1960, somente à partir da década de 70 teve aplicação comercial difundida em todo mundo.
O fabricante Texas Instruments foi que conseguiu inovar e fabricar Led vermelhos. No início, esses Leds serviam como indicadores luminosos para circuitos eletrônicos. E logo depois foi desenvolvido uma aplicação mais elaborada – o display de 7 segmentos.
A Texas inovou mais uma vez ao criar a primeira calculadora eletrônica digital com display de 7 segmentos. Naquela época, as calculadoras eram mecânicas. Imagine o sucesso que foi, ao introduzir no mercado mundial uma calculadora pequena, portátil e que funcionava com pilhas ! Eu presenciei toda essa evolução, e fiquei maravilhado quando a minha mãe comprou na década de 70, uma calculadora Texas TI-30 .
Como eu informei, os displays de 7 segmentos foram desenvolvidos à partir da evolução dos Leds. O Led é um diodo de material semicondutor que quando a corrente elétrica é passada por ele, uma luz é emitida. Devido à construção desse semicondutor, é necessária uma limitação de corrente, pois senão ele queima. Por isso, para a ligação de um Led, um resistor em série deve ser conectado. Perceba que cada segmento do Display é formado por um led. Ao acionar os segmentos, pode-se formar números e letras (com algumas limitações). É esse o princípio simples de funcionamento de um Display. Os segmentos são identificados com letras de A até G e mais DP para o ponto decimal. Existem dois tipos de displays, com o catodo comum e com o anodo comum. Como o nome já diz, no primeiro tipo, os catodos de todos os segmentos estão conectados em um único pino negativo. E no segundo tipo, os anodos estão conectados também em um só pino, mas positivo. Portanto as polarizações dos segmentos são inversas uma da outra.
Uma das desvantagens desse display, é o alto consumo de corrente. Por isso na calculadora da Texas, os dígitos eram bem pequeninos, para diminuir o consumo de energia já que funcionava com uma bateria de 9 Volts. Posteriormente foram desenvolvidos outros tipos de displays, como o de Cristal Líquido (LCD) com baixíssimo consumo de energia.
O legal do Display de 7 segmentos é que ele é visível em um ambiente com pouca luz, pois emite luz. E mesmo em um ambiente com luz solar, consegue-se ter uma boa visibilidade. Esses displays foram (e são ainda) muito usados em instrumentos do painel de carros esportivos.
Algumas aplicações comuns para Displays de 7 segmentos :
Existem basicamente dois métodos de controle dos Displays de 7 segmentos. O método de controle direto dos segmentos através de portas dos registradores e o método de multiplexação dos segmentos.
O método de controle deve ser analisado antes de montar um projeto, pois existem vantagens e desvantagens em cada método.
Método de controle direto dos segmentos:
Esse tipo de circuito tem a vantagem de emitir uma maior quantidade de luz, tornando-o mais visível. Mas ao mesmo tempo, gasta-se mais corrente. Como cada segmento sempre fica ligado ou desligado, um registrador é associado à cada um. Registrador no estado 1 aciona o segmento. Estado 0 apaga o segmento.
Analisando vários projetos de Displays de 7 segmentos com Arduino, a grande maioria usa as próprias portas do Microcontrolador para acionar os segmentos. Achei esses circuitos inapropriados para o Arduino. Não acho interessante usar 8 ou mais portas para acionamento dos displays, pois dessa forma, sobram poucas portas para outros dispositivos.
Usando o 8 bit I/O Expander PCF8574 :
Por isso, na primeira montagem usei o chip PCF8574. Esse chip contem 8 registradores que podem funcionar como entrada e ou como saída. No controle do display, os registradores são configurados como saída. Como a interface do chip é a I2C, apenas dois pinos são conectados nas portas do Arduino (SDA e SCL). E uma grande vantagem é que no barramento I2C, até oito PCF8574 podem ser usados, conectados em paralelo.
Esse é o diagrama do circuito de controle de dois displays de 7 segmentos (F5161BH- anodo comum) usando os chips PCF8574. Qualquer outro display anodo comum poderá ser usado, desde que não ultrapasse a capacidade de corrente do I/O Expander. Esse circuito é modular e poderá conectar até 8 displays em um mesmo barramento I2C. Para cada display é usado um chip.
Veja que existem muitas ligações entre os displays e o chip. Mas o controle do Arduino é feito através de apenas duas ligações da interface I2C. Para simplificar o diagrama, separei algumas ligações. Conecte as ligações identificadas por letras e cores. Para limitar a corrente nos leds, resistores de 220 ohms são conectados em série com os segmentos. Se precisar de mais brilho, pode usar resistores de até 100 ohms. Resistores de pullup de 4,7 K ohms são necessários nas ligações SDA e SCL da interface I2C. O chip PCF8574 da esquerda tem o endereço 0x21 e o da direita o endereço 0x20 (pinos A0,A1 e A2). São muitas ligações, portanto antes de energizar o circuito, confira todo a montagem.
O sketch para fazer funcionar os displays usando o PCF8574, foi desenvolvido por mim baseando-me em outros dois exemplos. Se for usar mais de 2 displays em um mesmo barramento I2C, terá que fazer algumas adaptações no programa.
O Programa faz a contagem de 0 a 99, sucessivamente.
// Arduino - Display 7 Segmentos com PCF8574
// https://blog.eletrogate.com/guia-completo-dos-displays-de-7-segmentos-arduino
// Interface Arduino I2C > SDA = A4 SCL = A5 Resistor 4K7 pullup
// baseado em https://www.instructables.com/id/Arduino-and-PCF8574-IO-Expander-Binary-Counter-and
// baseado em http://forum.arduino.cc/index.php?topic=307479.15
#include <Wire.h> // biblioteca wire
#define digito_1 0x20 // endereço do display digito 1 - lado direito
#define digito_2 0x21 // endereço do display digito 2 - lado esquerdo
int addressDisplay; // variável do endereço do display
int dataDisplay; // variável do dado do display
int atraso = 300; // atraso de 300 milisegundos
int n; // variável numero de dígitos
int digits[2]; // matriz com dois algarismos
long value; // variável do numero
long divider; // variável do divisor
void setup()
{
Wire.begin(); // inicializa a interface I2C
}
void pcf8574Write(byte address, byte data ) // envia dado para PCF8574 - interface I2C
{
Wire.beginTransmission(address); // envia o endereço do PCF8574
Wire.write(data); // envia o dado para o PCF8574
Wire.endTransmission(); // termina transmissão
}
void displayNumber ()
{
if (digits[n] == 0) dataDisplay = 0x81 ; // mostra número 0
if (digits[n] == 1) dataDisplay = 0xCF ; // mostra número 1
if (digits[n] == 2) dataDisplay = 0x92 ; // mostra número 2
if (digits[n] == 3) dataDisplay = 0x86 ; // mostra número 3
if (digits[n] == 4) dataDisplay = 0xCC ; // mostra número 4
if (digits[n] == 5) dataDisplay = 0xA4 ; // mostra número 5
if (digits[n] == 6) dataDisplay = 0xA0 ; // mostra número 6
if (digits[n] == 7) dataDisplay = 0x8F ; // mostra número 7
if (digits[n] == 8) dataDisplay = 0x80 ; // mostra número 8
if (digits[n] == 9) dataDisplay = 0x8C ; // mostra número 9
}
void printDisplay () // mostra algarismos em 2 displays
{
for (int i = 0; i < 100; i++) // contagem de 0 a 99
{
n = 2; // número de casas decimais
value = i ; // número a ser desmembrado em digitos
divider = 10; // divisor por 10
while (n--) // contagem regressiva dos dígitos
{
digits[n] = (value / divider); // carrega matriz com a divisão
value = value - (digits[n] * divider); // equação
divider = divider/10; // divisor dividido por 10
}
n = 2; // número de casas decimais
while (n--) // contagem regressiva dos dígitos
{
if (n == 0) // se for o primeiro dígito - lado direito
{
addressDisplay = digito_1 ; // endereça o PCF8574
displayNumber (); // mostra o número
}
if (n == 1) // se for o segundo dígito - lado esquerdo
{
addressDisplay = digito_2 ; // endereça o PCF8574
displayNumber (); // mostra o número
}
pcf8574Write(addressDisplay, dataDisplay); // envia dado para PCF8574 endereçado
}
delay (atraso); // atraso de tempo
}
}
void loop()
{
printDisplay (); // mostra a contagem nos displays
}
// Para mostrar carater A = 0x88
// Para mostrar carater B = 0xE0
// Para mostrar carater C = 0xB1
// Para mostrar carater D = 0xC2
// Para mostrar carater E = 0xB0
// Para mostrar carater F = 0xB8
// Para mostrar todos segmentos ligados = 0x00
Método de Multiplexação dos segmentos do Display :
A grande vantagem desse método, é que nesse caso são usados módulos de Displays que tem um número menor de pinos. Os segmentos dos dígitos são interligados internamente em paralelo. Portanto, temos 8 pinos para os segmentos (A até G e o ponto decimal) e mais um pino para cada dígito (algarismo).
Basicamente a multiplexação consiste no acionamento de um dígito por vez. Por exemplo, os segmentos do primeiro dígito são acionados e ao mesmo tempo o pino comum do mesmo é acionado também. No próximo passo, os segmentos do segundo dígito e o pino comum do mesmo são acionados. E assim por diante até mostrar todos os dígitos. E depois a sequência volta a ser iniciada e continuada.
Na multiplexação, o tempo de visualização é dividido entre os dígitos (números). Essa é uma das desvantagens, pois como o circuito é compartilhado entre os dígitos, menor corrente passará nos segmentos produzindo um menor brilho. Mas se o seu projeto pretende gastar menos energia, esse método é recomendado.
Usando o Display Driver MAX7219 :
Nessa montagem com multiplexação, usaremos o chip MAX7219. É um chip projetado para multiplexação de vários tipos de displays. Não somente os displays de 7 segmentos (até 8 dígitos) , mas também para displays com matrizes de 64 Leds ( 8 x 8 ) ! No chip existem vários registradores de controle como os dados dos dígitos, controle de brilho, tempo de varredura, teste do display, etc. A interface usada é a SPI. Mas somente três pinos são conectados ao Arduino (Load, DIN e CLK). Um detalhe importante é que esse chip foi projetado para controlar displays com catodo comum. Vi em um site, que é possível montar com displays com anodo comum, mas será necessário criar uma biblioteca dedicada e não posso afirmar se vai funcionar corretamente. Portanto use displays com catodo comum.
Esse é o digrama do circuito com o módulo Display com 4 Dígitos. A multiplexação dos segmentos é realizada pelo MAX7219. Como nesse circuito somente 4 dígitos são usados, alguns pinos de controle do chip não tem conexão. Como o diagrama ficaria muito complexo, separei os circuitos. Faça as ligações do MAX7219 com o módulo do display, obedecendo as identificações e cores de cada ligação. Veja que tem um resistor de 100K entre o pino 18 do MAX7219 e o 5V. Esse resistor serve para ajustar o brilho do display. São muitas ligações, portanto antes de energizar o circuito, confira todo a montagem. Não deixe de alimentar o Chip com 5V no pino 19.
O módulo do display é o CL5642-AS (catodo comum). Mas qualquer outro módulo com 4 dígitos (catodo comum – com 12 pinos) poderá ser usado, desde que não ultrapasse a capacidade de corrente do MAX7219 (veja as especificações). OBS: a sequência de conexões dos dígitos no chip MAX7219 está diferente (inversa) do datasheet.
A biblioteca usada para o funcionamento do módulo de display com o MAX7219 é a LedMatrixDriver. Para instalar a nova Biblioteca , clique em :
Sketch > Incluir Biblioteca > Gerenciar Bibliotecas
Após abrir a janela do Gerenciador de Biblioteca, refine a busca digitando LedMatrix . Na biblioteca LEDMatrixDriver , clique em More Info e depois em Instalar. Após alguns segundos, ela será automaticamente instalada. Lembre-se que o seu computador precisa estar conectado na internet, para poder baixar a biblioteca. Após a instalação da Biblioteca, é necessário que feche e abra novamente o programa Arduino IDE.
GitHub – Biblioteca LedMatrixDriver
O Sketch para o Display com MAX7219, usa a comunicação SPI. No display aparece a contagem do número 0 até 9999. E depois a palavra HELP. O programa foi desenvolvido baseando-me no exemplo da Biblioteca e no programa que eu fiz para o display com PCF8574.
// Arduino - Módulo Display 4 dígitos com MAX7219
// baseado no exemplo da biblioteca LedMatrixDriver
// https://blog.eletrogate.com/guia-completo-dos-displays-de-7-segmentos-arduino/
// SPI Interface MOSI(D11)= DIN , SCK(D13)= CLK
// Sequencia dos digitos invertida - Digito 0 é o mais da esquerda
#include <LEDMatrixDriver.hpp>
const int LEDMATRIX_CS_PIN = 6; // MAX7219 Load/CS(pin 12) = Arduino D6
const int NO_OF_DRIVERS = 1; // numero de chips MAX7219
int n; // variável numero de digitos
int digits[4]; // matriz com 4 algarismos
long value; // variável do valor
long divider; // variável do divisor
int digito; // variável do digito
int numero; // variável do valor do digito
int atraso = 200; // atraso de 200 milisegundos
LEDMatrixDriver lmd(NO_OF_DRIVERS, LEDMATRIX_CS_PIN); // inicializando a instância
void setup()
{
lmd.setEnabled(true); // ativa configuração
lmd.setIntensity(15); // configura brilho 0 = min, 15 = max
lmd.setScanLimit(3); // 0-7: mostra 4 digitos n+1
lmd.setDecode(0xFF); // ativa "BCD tipo B"
}
void loop()
{
for (int i = 0; i < 10000; i++) // contagem de 0 a 9999
{
n = 4; // numero de casas decimais
value = i ; // numero a ser desmembrado em digitos
divider = 1000; // divisor por 1000
while (n--) // contagem regressiva dos dígitos
{
digits[n] = (value / divider); // carrega matriz com a divisão
value = value - (digits[n] * divider); // equação
divider = divider / 10; // divisor dividido por 10
}
n = 4; // numero de casas decimais
while (n--) // contagem regressiva do dígitos
{
if (n == 0) digito = 0; // endereça o digito 4
if (n == 1) digito = 1; // endereça o digito 3
if (n == 2) digito = 2; // endereça o digito 2
if (n == 3) digito = 3; // endereça o digito 1
numero = digits[n]; // numero a ser mostrado
lmd.setDigit(digito, numero, false); // setDigit (digito, valor, bool ponto decimal)
lmd.display(); // mostra no display
}
delay (atraso); // atraso de tempo
}
lmd.setDigit(3, LEDMatrixDriver::BCD_H); // mostra a palavra HELP por um segundo
lmd.setDigit(2, LEDMatrixDriver::BCD_E);
lmd.setDigit(1, LEDMatrixDriver::BCD_L);
lmd.setDigit(0, LEDMatrixDriver::BCD_P);
lmd.display(); // mostra no display
delay(1000); // atraso de 1 segundo
}
O Chip TM1637 é dedicado para esse tipo de aplicação. Ele controla toda a multiplexação do módulo de display com até seis dígitos. Considero um dos mais simples e mais eficientes circuitos controladores de display. E ele usa somente dois pinos para interface, apesar de não ser I2C. Ele também tem um registrador para controle de brilho do display. Para maiores informações, veja o datasheet.
Esse é o digrama de montagem do Módulo Display TM1637 com Arduino. A montagem é bem simples. A alimentação do módulo pode ser feita com o 5V do Arduino. Eu medi o consumo de corrente com todos os dígitos ativados = 42 mA aproximadamente. E o brilho do display é muito bom.
A biblioteca usada para teste do Módulo TM1637 é a TM1637. Para instalar a nova Biblioteca TM1637 , clique em :
Sketch > Incluir Biblioteca > Gerenciar Bibliotecas
Após abrir a janela do Gerenciador de Biblioteca, refine a busca digitando TM1637. Na biblioteca TM1637 , clique em More Info e depois em Instalar. Após alguns segundos, ela será automaticamente instalada. Lembre-se que o seu computador precisa estar conectado na internet, para poder baixar a biblioteca. Após a instalação da Biblioteca, é necessário que feche e abra novamente o programa Arduino IDE.
Esse é o Sketch para teste do Módulo Display TM1637. Editei-o baseando-me no exemplo da Biblioteca. No exemplo tem mais alternativas de uso, mas simplifiquei-o para facilitar a compreensão.
// Arduino - Modulo Display TM1637
// baseado no exemplo da biblioteca TM1637
// https://blog.eletrogate.com/guia-completo-dos-displays-de-7-segmentos-arduino/
#include <Arduino.h> // biblioteca Arduino
#include <TM1637Display.h> // biblioteca TM1637
#define CLK 2 // pino D2 Arduino conectado ao pino CLK do modulo TM1637
#define DIO 3 // pino D2 Arduino conectado ao pino DIO do modulo TM1637
#define TEST_DELAY 1000 // atraso de tempo entre os testes do display = 1 segundo
const uint8_t SEG_DONE[] = // matriz com a palavra 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
};
TM1637Display display(CLK, DIO); // inicializa o objeto
void setup()
{
}
void loop()
{
int k;
uint8_t data[] = { 0xff, 0xff, 0xff, 0xff }; // matriz todos os bits ON
display.setBrightness(0x0f); // controle do brilho 0F = maximo
display.setSegments(data); // teste do display - todos segmentos ativados
delay(TEST_DELAY);
data[0] = display.encodeDigit(0); // display mostrando o numero 0123
data[1] = display.encodeDigit(1);
data[2] = display.encodeDigit(2);
data[3] = display.encodeDigit(3);
display.setSegments(data);
delay(TEST_DELAY);
display.showNumberDec(321, true); // Mostra 0301 com zero à esquerda
delay(TEST_DELAY);
display.showNumberDec(321, false); // Mostra _301 sem zero à esquerda
delay(TEST_DELAY);
display.showNumberDec(-27, false); // Mostra -27 sem zero à esquerda
delay(TEST_DELAY);
display.setSegments(SEG_DONE); // mostra a palavra dOnE
delay(TEST_DELAY);
}
Display de 7 segmentos – Wikipedia
Como testar um display de 7 segmentos – anodo ou catodo comum? – YouTube
Usando Displays de 7 segmentos – parte 1 – Nuts & Volts
Usando Displays de 7 segmentos – parte 2 – Nuts & Volts
Datasheet de vários Displays de 7 segmentos
|
A Eletrogate é uma loja virtual de componentes eletrônicos do Brasil e possui diversos produtos relacionados à Arduino, Automação, Robótica e Eletrônica em geral.
Conheça a Metodologia Eletrogate e Lecione um Curso de Robótica nas Escolas da sua Região!
Rua Rio de Janeiro, 441 - Sala 1301
Centro - Belo Horizonte/MG
CEP 30160-041
*Não temos atendimento físico
ANWAR SLEIMAN HACHOUCHE - ME
CNPJ: 18.917.521/0001-73
