O que é um display de 7 segmentos?
Um display de 7 segmentos é um componente eletrônico composto por 7 LEDs individuais dispostos em um padrão específico para exibir dígitos (0-9) e algumas letras. Esses LEDs são denominados a, b, c, d, e, f, g, e o display normalmente inclui um ponto decimal opcional (dp).
De acordo com diferentes arranjos e combinações, existem 128 variações (algarismos arábicos e caracteres) para o visor de 7 segmentos.
Pinagem do visor de 7 segmentos
A pinagem de um display de 7 segmentos varia de acordo com o seu tipo, que se divide principalmente em duas categorias: ânodo comum e cátodo comum.
Configuração da pinagem
A seguir, apresentamos um exemplo de atribuição de pinos para um display típico de 7 segmentos (observe que as configurações reais dos pinos podem variar dependendo do fabricante e do modelo):
Ânodo comum:
Todos os ânodos (positivos) do display de 7 segmentos estão conectados entre si e, quando um cátodo é puxado para baixo, o LED correspondente acende.
- g, f, a, b, e, d, c, dp: Estes são os pinos dos segmentos, correspondentes aos sete segmentos e ao ponto decimal, respectivamente.
- COM: O pino ânodo comum, conectado ao VCC.
Cátodo comum:
Todos os cátodos (negativos) do display de 7 segmentos estão conectados entre si e, quando um ânodo (positivo) é puxado para cima, o LED correspondente acende.
Da mesma forma, os pinos dos segmentos (g, f, a, b, e, d, c, dp) correspondem aos segmentos e ao ponto decimal, mas o pino do cátodo comum (COM) está conectado ao GND.
Conectando o display de 7 segmentos
Para operar um display de 7 segmentos, os segmentos individuais (a, b, c, d, e, f, g, dp) precisam ser conectados a pinos de saída específicos em um microcontrolador. Por exemplo, para um display de 7 segmentos com cátodo comum, a extremidade negativa de cada segmento é conectada a um pino terra comum, enquanto a extremidade positiva de cada segmento é conectada a um pino de saída diferente no microcontrolador.
Configuração básica da fiação
- O display de 7 segmentos tem 8 pinos (7 para os segmentos e 1 para o ponto decimal).
- Cada pino correspondente a um segmento (a a g) está conectado ao microcontrolador.
- Para a configuração de cátodo comum, conecte o pino do cátodo comum ao terra.
Exemplo de conexão com Arduino
Ao conectar um display de 7 segmentos a um Arduino, os pinos dos segmentos são normalmente conectados a diferentes pinos digitais na placa Arduino. Por exemplo, em uma configuração de ânodo comum, os pinos dos segmentos podem ser conectados da seguinte forma:
- a – Pino 7 do Arduino
- b – Pino 8 do Arduino
- c – Pino 4 do Arduino
- d – Pino 3 do Arduino
- e – Pino 2 do Arduino
- f – Pino 6 do Arduino
- g – Pino 5 do Arduino
- COM – Pino 9 do Arduino (conectado ao VCC)
Nesta configuração, para iluminar um segmento específico, o pino Arduino correspondente é definido como LOW, enquanto o pino ânodo comum permanece HIGH.
Como controlar um display de 7 segmentos
A chave para controlar um display de 7 segmentos é fornecer a tensão correta aos segmentos individuais para formar o número ou símbolo desejado.
Exibindo números
Para exibir um número, o microcontrolador precisa ativar os segmentos apropriados. Por exemplo:
- Para exibir 0, os segmentos a, b, c, d, e e f devem estar iluminados, enquanto o segmento g permanece desligado.
Componentes necessários
Semelhante a uma matriz LED, este projeto exigirá uma quantidade considerável de fiação e resistores. Como cada LED precisa de seu próprio resistor para evitar queimaduras, certifique-se de ter resistores suficientes preparados. Para todo o projeto, você precisará dos seguintes componentes:
- Arduino Uno
- Arduino IDE
- Visor de sete segmentos
- Fios elétricos
- 8 resistores de 220 ohms
- Placa de ensaio
- Cabo USB
Código de exemplo para exibir números
int pin_a = 7, pin_b= 6, pin_c = 5, pin_d = 10, pin_e = 11, pin_f = 8, pin_g = 9, pin_p = 4;
// Segment data for digits 0-9
int numTable[10][8] = {
{1, 1, 1, 1, 1, 1, 0, 0}, // 0
{0, 1, 1, 0, 0, 0, 0, 0}, // 1
{1, 1, 0, 1, 1, 0, 1, 0}, // 2
{1, 1, 1, 1, 0, 0, 1, 0}, // 3
{0, 1, 1, 0, 0, 1, 1, 0}, // 4
{1, 0, 1, 1, 0, 1, 1, 0}, // 5
{1, 0, 1, 1, 1, 1, 1, 0}, // 6
{1, 1, 1, 0, 0, 0, 0, 0}, // 7
{1, 1, 1, 1, 1, 1, 1, 0}, // 8
{1, 1, 1, 1, 0, 1, 1, 0}, // 9
};
void setup(){
for (int i = 4; i <= 11; i++){
pinMode(i, OUTPUT);
}
}
void loop(){
for (int i = 0; i < 10; i++){
digitalWrite(pin_a, numTable[i][0]);
digitalWrite(pin_b, numTable[i][1]);
digitalWrite(pin_c, numTable[i][2]);
digitalWrite(pin_d, numTable[i][3]);
digitalWrite(pin_e, numTable[i][4]);
digitalWrite(pin_f, numTable[i][5]);
digitalWrite(pin_g, numTable[i][6]);
digitalWrite(pin_p, numTable[i][7]);
delay(1000);
}
}
Neste exemplo, a numTable matriz contém os dados necessários para ativar os segmentos apropriados para cada dígito.
Projetos com display de 7 segmentos com vários dígitos
Para displays com vários dígitos, a maneira mais simples de controlar vários displays de 7 segmentos é através da multiplexação. Outra maneira é usar a biblioteca Arduino.
Técnica de multiplexação
Com a multiplexação, vários visores compartilham o mesmo conjunto de pinos de controle, e cada visor é ligado sequencialmente. Isso é feito tão rapidamente que o olho humano percebe todos os dígitos como acesos ao mesmo tempo.
Código de exemplo para multiplexação de displays de 7 segmentos
const int digitPins[3] = {2, 3, 4}; // Digit selection pins
const int segmentPins[8] = {6, 7, 8, 9, 10, 11, 12, 13}; // Segment pins
int numTable[10][8] = { {0, 0, 0, 0, 0, 0, 1, 1}, {1, 0, 0, 1, 1, 1, 1, 1}, ... };
void setup(){
for (int i = 2; i <= 4; i++) {
pinMode(i, OUTPUT);
digitalWrite(i, LOW);
}
for (int i = 6; i <= 13; i++) {
pinMode(i, OUTPUT);
digitalWrite(i, HIGH);
}
}
void loop(){
for (int i = 0; i < 10; i++){
for (int j = 0; j < 3; j++) {
showdigit(i, j);
}
delay(500);
}
}
void showdigit(int num, int digit){
digitalWrite(digitPins[digit], HIGH);
for (int i = 0; i < 8; i++) {
digitalWrite(segmentPins[i], numTable[num][i]);
}
delay(500);
digitalWrite(digitPins[digit], LOW);
}
Usando bibliotecas para controlar displays de 7 segmentos
Por conveniência, bibliotecas como SevSeg estão disponíveis para simplificar o controle de displays de 7 segmentos. Essa biblioteca é útil para controlar displays com vários dígitos, pois abstrai grande parte da complexa lógica de fiação e controle.
Podemos pesquisar e instalar o SevSeg pelo menu do Arduino: Ferramentas >> Gerenciar Bibliotecas.
Código de exemplo usando a biblioteca SevSeg
#include "SevSeg.h"
SevSeg sevseg;
void setup() {
sevseg.begin(COMMON_CATHODE, 3, digitPins, segmentPins);
}
void loop() {
int readValue = analogRead(A0);
int showValue = map(readValue, 0, 1023, 0, 999);
sevseg.setNumber(showValue, 3);
sevseg.refreshDisplay();
}
Aplicações dos visores de 7 segmentos
Devido à sua simplicidade, facilidade de uso e baixo custo, o display de 7 segmentos é amplamente utilizado em várias aplicações, tais como:
- Relógios eletrônicos: exibição da hora e data;
- Calculadoras: exibição dos resultados dos cálculos;
- Eletrodomésticos: painéis de exibição para produtos como micro-ondas, aparelhos de ar condicionado e máquinas de lavar;
- Painéis de instrumentos de automóveis: exibição de informações como velocidade e quilometragem;
- Equipamentos industriais: exibição de leituras de dispositivos como controladores de temperatura e medidores de pressão;
- Instrumentos de laboratório: exibição de dados e resultados experimentais;
- Eletrônicos de consumo: display de controle de volume em equipamentos de áudio.
Conclusão
Os displays de 7 segmentos são componentes versáteis que permitem a exibição simples de dados numéricos. Compreender sua fiação, métodos de controle e aplicações pode melhorar significativamente a funcionalidade de seus projetos, desde relógios simples até displays complexos. Seja usando multiplexação, bibliotecas ou registros de deslocamento, há muitas maneiras de controlar displays de 7 segmentos de forma eficaz, cada uma adequada a diferentes requisitos de projeto.
