No tutorial anteriordiscutimos a interface de LEDs RGB com Arduíno. Neste tutorial, você aprenderá como fazer a interface do display de sete segmentos (SSD) ao usar o Arduino.
Ao fazer interface com qualquer tipo de dispositivo de exibição, o Arduino e outros controladores usam saída digital ou comunicação serial. Conduzir SSDs pelo Arduino é tão simples quanto colocar um LED nele. O display de sete segmentos é composto por oito segmentos de LED. Eles são usados para exibir números.
Neste tutorial, projetaremos um contador simples usando um SSD que conta de 0 a 9 e arredonda.
Monitores de sete segmentos (SSDs)
Conforme mencionado na introdução, um SSD é uma unidade composta por oito segmentos de LED. Destes oito segmentos de LED, sete são em forma de barra e um é um ponto.
Existem 10 pinos no total em um SSD. Desses 10 pinos, dois pinos são cátodo comum ou ânodo comum, e os demais estão conectados a terminais opostos dos segmentos de LED.
SSDs são usados para exibir números. Eles são menos dispendiosos e frequentemente empregados como uma alternativa aos LCDs de caracteres. Eles são usados em aplicações embarcadas onde o display só precisa mostrar números. Pegue um relógio digital, por exemplo, que exibe a hora em números. Ele pode ser construído usando SSDs em vez de um LCD caro.
Uma placa de exibição de tokens também pode ser construída usando SSDs, pois só precisa exibir números de tokens. Da mesma forma, os SSDs podem ser usados em painéis digitais (como os dos painéis dos veículos), que exibem informações numéricas (distância percorrida, eficiência de combustível, etc.).
Além disso, os SSDs são usados em diversas aplicações incorporadas e de consumo onde dados numéricos são exibidos.
Alguns exemplos incluem:
- O temporizador de exibição para um micro-ondas ou máquina de lavar
- O medidor de temperatura em um aquecedor ou ar condicionado
- O valor de uma máquina de contagem de moeda
- Os números em uma calculadora, etc.
Tipos de SSD
Existem dois tipos de SSDs:
1. Ânodo comum
2. Cátodo comum
No SSD de ânodo comum, o ânodo de cada um dos segmentos de LED possui um terminal comum, enquanto os cátodos possuem terminais separados. Para controlar cada segmento, o ânodo comum é conectado ao VCC e os terminais do cátodo são exibidos como “lógico LOW” para ligar os segmentos e “lógico HIGH” para desligá-los.
No SSD de cátodo comum, os cátodos se cada um dos segmentos de LED possuem um terminal comum, enquanto os ânodos possuem terminais separados. Para controlar cada segmento, o cátodo comum é conectado ao terra e os terminais do ânodo são exibidos como “lógico HIGH” para ligar os segmentos e “lógico LOW” para desligá-los.
Como funciona o SSD
Existem oito segmentos de LED em um SSD, dos quais sete são em forma de barra e um em forma de ponto. Os segmentos de LED em forma de barra são designados pelas letras do alfabeto “A” a “G” e o segmento de LED em forma de ponto é designado por “DP”.
Esses segmentos de LED estão organizados no SSD assim:
Ao acender combinações específicas dos segmentos de LED, diferentes dígitos decimais (0 a 9) e alfabetos hexadecimais (A a F) podem ser exibidos.
Um display de sete segmentos possui a seguinte configuração de pinos:
SSDs têm este diagrama de circuito interno:
No SSD de ânodo comum, o terminal comum é o ânodo de cada um dos segmentos de LED. Para exibir diferentes dígitos e alfabetos hexadecimais, os segmentos de LED do SSD de ânodo comum devem ser fornecidos como lógica digital.
Esta tabela oferece um resumo:
No SSD de cátodo comum, o terminal comum é o cátodo com todos os segmentos de LED. Para exibir diferentes dígitos e alfabetos hexadecimais, os segmentos de LED do SSD de cátodo comum devem ser fornecidos como uma lógica digital.
Esta tabela oferece um resumo:
A tabela lógica para o cátodo comum é simplesmente o inverso do SSD de ânodo comum. Para proteger os segmentos de LED, é aconselhável conectar resistores limitadores de corrente em série com cada segmento.
No entanto, diferentes segmentos de LED podem ter diferentes tensões de polarização direta. Portanto, os resistores devem ser conectados ao longo de cada segmento, em vez de conectar um único resistor ao terminal comum. Se um único resistor estiver conectado ao terminal comum, alguns dos segmentos de LED podem não brilhar porque podem ter uma tensão direta mais alta. Alternativamente, todos os segmentos podem brilhar, mas com intensidade de luz diferente.
O valor do resistor deve ser calculado de acordo com o segmento com maior tensão direta.
O valor do resistor pode ser calculado usando esta equação:
Série RS = (VS – VLED)/ILED
Onde,
RSeries = Valor do resistor
VS = Tensão da fonte
VLED = Tensão direta mais alta dos segmentos de LED
ILED = Corrente através de segmentos de LED
Suponhamos que a tensão direta mais alta seja 1,7 V, a tensão da fonte seja 5 V e a corrente necessária através dos segmentos de LED seja de 5 mA a 20 mA – ou considere a média de 10 mA.
Então, o valor dos resistores será:
R = (5-1,7)/10×10-3
= 330 Ohms
Conduzindo SSD com Arduino
A interface do SSD com o Arduino é tão simples quanto a interface dos LEDs. O SSD pode ser tratado como uma coleção de oito LEDs com um ânodo ou cátodo comum.
As instruções:
- Para acionar o SSD de ânodo comum, o terminal comum é conectado ao VCC e o restante dos terminais tem interface direta com os canais de E/S digital do Arduino por meio de resistores em série. Os canais devem ser configurados em BAIXO para LIGAR os segmentos de LED e devem ser configurados em ALTO para desligá-los.
- Para acionar o SSD de cátodo comum, o terminal comum é conectado ao terra e o restante dos terminais tem interface direta com os canais de E/S digital do Arduino por meio dos resistores em série. Neste caso, os canais devem ser configurados em HIGH para ligar os segmentos de LED, e devem ser configurados em LOW para desligá-los.Os canais de E/S digital do Arduino produzem 5V/3,3V e fontes ou dissipadores de corrente de até 40 mA, o que é suficiente para acionar os segmentos de LED. Ao ligar e desligar as diferentes combinações de segmentos de LED, diferentes dígitos (0 a 9) e alfabetos (A a F) podem ser exibidos.
- Para conduzir mais de um SSD juntos, é usada uma técnica de multiplexação. Quando há muitos SSDs que precisam ser controlados por um controlador, os SSDs são interligados por meio de um demultiplexador ou IC decodificador de BCD para sete segmentos, como SN7446AN.
Receita de driver SSD baseado em Arduino
Nesta receita, faremos a interface de um display de sete segmentos usando Arduino UNO e exibirá dígitos de 0 a 9 nele.
Componentes necessários
1. Arduino UNO x1
2. SSD x1
3. Resistor de 330 Ohms x7
4. Tábua de ensaio x1
5. Fios de ligação macho-macho ou fios de conexão
Conexões de circuito
O SSD usado neste projeto é do tipo ânodo comum. Isso significa que o terminal comum do SSD está conectado a 5V DC. Os terminais A, B, C, D, E, F e G do SSD estão conectados aos canais de E/S digital 4, 5, 6, 0, 1, 2 e 3, respectivamente.
Resistores de 330 Ohms são conectados entre cada canal e os respectivos terminais SSD. A placa de ensaio é fornecida como aterramento comum e trilho de alimentação de 5 V de um dos pinos de aterramento e pino de 5 V do Arduino UNO, respectivamente.
Diagrama de circuito
Esboço do Arduino
Como funciona o projeto
Para exibir diferentes dígitos no SSD, diferentes combinações de segmentos de LED são LIGADAS e DESLIGADAS ao mesmo tempo.
O SSD usado neste projeto é do tipo ânodo comum. Assim, o terminal comum do SSD é conectado a 5V DC e os demais terminais são interligados com os canais do Arduino através de resistores em série de 330 Ohms.
Para exibir dígitos diferentes, é aplicável a tabela lógica para um ânodo comum de sete segmentos.
Para dígitos piscantes de 0 a 9, o “0” é exibido primeiro ligando os segmentos de LED A, B, C, D, E e F – enquanto o segmento de LED G é desligado. Depois de exibir “0” por um segundo, todos os segmentos de LED são desligados por 300 milissegundos. Nota: se todos os segmentos não estiverem desligados, os segmentos de LED permanecerão acesos quando forem ligados novamente e os dígitos sucessivos não serão exibidos corretamente.
Depois de exibir “0”, se todos os segmentos do LED não estiverem desligados, ao exibir “1”, o SSD ainda exibirá “0”. Ele exibirá “8” quando 2, 3, 4, 5, 6, 8 e 9 piscarem e, em seguida, “0” quando 7 piscar. Portanto, é importante desligar todos os segmentos do LED por alguns milissegundos após a exibição de cada dígito.
Então, por exemplo:
- Para exibir “1”, os segmentos de LED B e C são LIGADOS enquanto todos os demais estão DESLIGADOS.
- Para exibir “2”, os segmentos de LED A, B, G, E e D são LIGADOS enquanto todos os demais estão DESLIGADOS.
- Para exibir “3”, os segmentos de LED A, B, G, C e D são LIGADOS enquanto todos os demais estão DESLIGADOS.
- Para exibir “4”, os segmentos de LED F, G, B e C são LIGADOS enquanto todos os demais estão DESLIGADOS.
- Para exibir “5”, os segmentos de LED A, F, G, C e D são LIGADOS enquanto todos os demais estão DESLIGADOS.
- Para exibir “6”, os segmentos de LED A, F, G, E, D e C são ligados enquanto todos os demais estão desligados.
- Para exibir “7”, os segmentos de LED A, B e C são ligados enquanto todos os demais estão desligados.
- Para exibir “8”, todos os segmentos de LED (exceto DP) estão LIGADOS.
- Para exibir “9”, os segmentos de LED A, B, F, G e C são LIGADOS enquanto todos os demais estão DESLIGADOS.
Todos os segmentos de LED são desligados por 300 milissegundos após exibir um dígito por um segundo. À medida que o Arduino repete seu código, a exibição dos dígitos de 0 a 9 continuará repetindo até que o Arduino seja desligado.
Guia de programação
O esboço do Arduino começa definindo as variáveis globais, que correspondem aos terminais SSD que estão conectados aos canais do Arduino.
intg = 3;
int f = 2;
intuma = 4;
int b = 5;
interno c = 6;
int d = 0;
int e = 1;
Na função setup , esses canais são definidos como saída digital usando a função pinMode .
configuração vazia {
pinMode(a, SAÍDA);
pinMode(b, SAÍDA);
pinMode(c, SAÍDA);
pinMode(d, SAÍDA);
pinMode(e, SAÍDA);
pinMode(f, SAÍDA);
pinMode(g, SAÍDA);
}
Na função loop , os dígitos lógicos para flash de 0 a 9 são escritos no SSD. Como o SSD utilizado neste projeto é um ânodo comum, ao escrever “lógico HIGH” em um canal, o respectivo segmento de LED apaga; e ao escrever “lógico LOW” em um canal, o respectivo segmento de LED acende.
Primeiro, todos os segmentos de LED são desligados escrevendo “lógico HIGH” em todos os canais interligados usando a função digitalWrite . Um atraso de 300 milissegundos é fornecido após usar a função delay .
loop vazio {
digitalWrite(a, ALTO);
digitalWrite(b, ALTO);
digitalWrite(c, ALTO);
digitalWrite(d, ALTO);
digitalWrite(e, ALTO);
digitalWrite(f, ALTO);
digitalWrite(g, ALTO);
atraso(300);
A seguir, o primeiro dígito “0” é exibido ligando os segmentos A, B, C, D, E e F do LED, o que é feito escrevendo “lógico LOW” nos respectivos canais.
Um atraso de um segundo é fornecido chamando a função delay , de forma que o dígito “0” permaneça exibido no SSD por um segundo.
digitalWrite(a, BAIXO);
digitalWrite(b, BAIXO);
digitalWrite(c, BAIXO);
digitalWrite(d, BAIXO);
digitalWrite(e, BAIXO);
digitalWrite(f, BAIXO);
atraso(1000);
Depois de exibir “0”, todos os segmentos de LED são desligados por 300 milissegundos.
Em seguida, o dígito “1” é exibido por um segundo apenas ligando os segmentos B e C do LED.
digitalWrite(a, ALTO);
digitalWrite(b, ALTO);
digitalWrite(c, ALTO);
digitalWrite(d, ALTO);
digitalWrite(e, ALTO);
digitalWrite(f, ALTO);
digitalWrite(g, ALTO);
atraso(300);
digitalWrite(b, BAIXO);
digitalWrite(c, BAIXO);
atraso(1000);
Da mesma forma, os outros dígitos restantes (de 2 a 9) são exibidos por um segundo cada, ligando e desligando seletivamente os segmentos de LED.
Depois de exibir cada dígito por um segundo, todos os segmentos são desligados por 300 milissegundos. E, após exibir o dígito “9”, o código escrito na função loop continua se repetindo – piscando cada dígito (de 0 a 9) por um segundo cada, por um número infinito de vezes.
No próximo tutorial, discutiremos a multiplexação de SSDs.
Vídeo de demonstração
(tagsParaTraduzir)Arduino
