Como usar um display de 7 segmentos: mostrando números com Arduino, ânodo comum vs cátodo comum

Um display de 7 segmentos é um indicador simples formado por sete LEDs em forma de barra, dispostos como o número "8", mais um pequeno ponto. Relógios digitais, timers de micro-ondas, placares e bombas de combustível usam esse display. Ele é barato, muito brilhante e fácil de ler mesmo de longe. Em projetos com Arduino, é uma das saídas clássicas para montar contadores, dados, cronômetros e relógios.

Como funciona um display de 7 segmentos?

Os segmentos são identificados por letras: começando pelo a, em cima, e seguindo no sentido horário vêm o b (em cima à direita), o c (embaixo à direita), o d (embaixo), o e (embaixo à esquerda) e o f (em cima à esquerda); a barra do meio é o g e o ponto é o dp. Cada segmento é, na verdade, um LED separado, e dígitos diferentes se formam conforme os segmentos que estão acesos. Para o "1", por exemplo, só o b e o c acendem, enquanto o "8" acende os sete.

Cátodo comum ou ânodo comum?

Assim como em um LED RGB, uma das pontas de todos os segmentos é unida em um pino comum. Em um display de cátodo comum, o pino comum vai no GND e um segmento acende quando você dá HIGH para ele. Em um display de ânodo comum, o pino comum vai no 5V e um segmento acende quando você dá LOW. Por fora eles parecem iguais; para descobrir qual é o seu, ligue o pino comum no GND e encoste um pino de segmento no 5V através de um resistor de 220 Ω. Se o segmento acender, é de cátodo comum; se não, inverta a ligação e tente de novo.

Pinagem e ligação no Arduino

Nos displays comuns de um dígito com 10 pinos, os pinos são numerados no sentido anti-horário a partir do canto inferior esquerdo, com a frente do display virada para você. Os dois pinos do meio (3 e 8) são o terminal comum e estão ligados entre si por dentro. A tabela abaixo mostra os pinos do display e os pinos do Arduino usados pelo código deste post:

Contando de 0 a 9 com o Arduino

Guardar em um array, como bits, quais segmentos cada dígito acende deixa o código curto. No exemplo abaixo, o bit mais à esquerda de cada byte é o segmento a e o bit mais à direita é o segmento g. A função showDigit() lê esses bits um por um e os escreve nos pinos; se você estiver usando um display de ânodo comum, basta definir COMMON_ANODE como true.

1const int SEG_PINS[7] = {2, 3, 4, 5, 6, 7, 8};   // a, b, c, d, e, f, g
2const bool COMMON_ANODE = false;                 // ortak anotsa true / true for common anode
3
4// her rakam için a–g segmentleri (1 = yanar) / a–g segments per digit (1 = on)
5const byte DIGITS[10] = {
6  0b1111110, // 0
7  0b0110000, // 1
8  0b1101101, // 2
9  0b1111001, // 3
10  0b0110011, // 4
11  0b1011011, // 5
12  0b1011111, // 6
13  0b1110000, // 7
14  0b1111111, // 8
15  0b1111011  // 9
16};
17
18void showDigit(int n) {
19  for (int i = 0; i < 7; i++) {
20    bool on = DIGITS[n] & (1 << (6 - i));       // a en soldaki bit / a is the leftmost bit
21    digitalWrite(SEG_PINS[i], COMMON_ANODE ? !on : on);
22  }
23}
24
25void setup() {
26  for (int i = 0; i < 7; i++) pinMode(SEG_PINS[i], OUTPUT);
27}
28
29void loop() {
30  for (int n = 0; n <= 9; n++) {
31    showDigit(n);
32    delay(1000);
33  }
34}

Displays de 4 dígitos e multiplexação

Um display de quatro dígitos não tem 32 pinos de segmento separados; ele tem só 12 pinos: 8 linhas de segmento (a–g e dp) compartilhadas por todos os dígitos e 4 pinos que escolhem qual dígito acende. Como as linhas de segmento são compartilhadas, você não consegue mostrar números diferentes em dígitos diferentes no mesmo instante. A solução é a multiplexação: você acende só o 1º dígito por alguns milissegundos, depois o 2º, o 3º e o 4º. Quando esse ciclo se repete mais de 50 vezes por segundo, o olho vê os quatro dígitos acesos ao mesmo tempo. Em vez de escrever essa varredura à mão, é muito mais fácil usar a biblioteca SevSeg:

1#include "SevSeg.h"
2
3SevSeg sevseg;
4
5void setup() {
6  byte digitPins[] = {2, 3, 4, 5};                    // hane seçme pinleri / digit select pins
7  byte segmentPins[] = {6, 7, 8, 9, 10, 11, 12, 13};  // a, b, c, d, e, f, g, dp
8  sevseg.begin(COMMON_CATHODE, 4, digitPins, segmentPins, true);  // dirençler segmentlerde / resistors on segments
9  sevseg.setBrightness(90);
10}
11
12void loop() {
13  sevseg.setNumber(millis() / 1000);   // geçen saniye / elapsed seconds
14  sevseg.refreshDisplay();             // sürekli çağrılmalı / must be called continuously
15}

O módulo TM1637: 4 dígitos com apenas 2 fios

Se 12 fios e uma varredura constante parecem trabalho demais, o módulo TM1637 é para você. O chip controlador dele faz a multiplexação sozinho; o Arduino só diz qual número mostrar pelos pinos CLK e DIO. A maioria das versões também tem dois-pontos (:) no meio, para montar relógios. Instale a biblioteca TM1637 de Avishay Orpaz pelo Gerenciador de Bibliotecas; o código abaixo mostra minutos e segundos com os dois-pontos:

1#include <TM1637Display.h>
2
3TM1637Display display(2, 3);   // CLK, DIO
4
5void setup() {
6  display.setBrightness(5);    // 0–7
7}
8
9void loop() {
10  int minutes = (millis() / 60000) % 60;
11  int seconds = (millis() / 1000) % 60;
12  // ortadaki iki noktayla dakika:saniye / minutes:seconds with the colon
13  display.showNumberDecEx(minutes * 100 + seconds, 0b01000000, true);
14  delay(200);
15}

Displays de 7 segmentos com o ESP32 e o Raspberry Pi Pico

Você pode ligar um display de um dígito direto em um ESP32 ou Pico; como os pinos têm saída de 3,3 V, os segmentos ficam um pouco mais fracos, então use resistores menores, como 100–150 Ω. O módulo TM1637 também funciona com 3,3 V e é usado no ESP32 com a mesma biblioteca do Arduino. No Pico com MicroPython, basta copiar para o Pico o arquivo tm1637.py (a biblioteca de mcauser):

1import tm1637
2from machine import Pin
3import time
4
5tm = tm1637.TM1637(clk=Pin(16), dio=Pin(17))   # tm1637.py Pico'da olmalı / tm1637.py must be on the Pico
6tm.brightness(4)                               # 0–7
7
8count = 0
9while True:
10    tm.number(count)        # -999 … 9999
11    count += 1
12    time.sleep(1)

7 segmentos, LCD ou OLED?

Se você só precisa mostrar números e a leitura a distância importa, o display de 7 segmentos é imbatível. Se precisa de texto, unidades e menus, dê uma olhada em Como usar um display LCD I2C.

Ideias de projetos com display de 7 segmentos

• Dado eletrônico: mostre um número aleatório de 1 a 6 quando um botão for apertado.
• Contador com botão: faça um contador que sobe com um botão e zera com outro.
• Relógio digital: um relógio com um TM1637 e um módulo RTC, que mantém a hora mesmo quando falta energia.
• Contagem regressiva: um timer ajustável para jogos de tabuleiro ou experimentos.
• Indicador de temperatura: mostre em dígitos grandes a temperatura medida com um DHT11.
• Teste de reação: mostre em milissegundos a rapidez com que você aperta o botão depois que um LED acende.

Erros comuns e como resolvê-los

• Nenhum segmento acende: o pino comum está no lugar errado; você pode ter ligado um display de ânodo comum no GND.
• Os dígitos aparecem embaralhados: a correspondência entre os segmentos e os pinos do Arduino está errada; confira acendendo um segmento de cada vez.
• Alguns dígitos ficam fracos: há um único resistor no pino comum; use um resistor separado para cada segmento.
• Só um dígito acende ou fica piscando em um display de 4 dígitos: há um delay() no loop(), ou a varredura não acontece com a frequência necessária.
• Os segmentos que deviam acender ficam apagados e os outros acendem: ânodo comum e cátodo comum estão trocados; mude o COMMON_ANODE.
• Faltam pinos: reduza o número de pinos com um módulo TM1637, um driver MAX7219 ou um registrador de deslocamento 74HC595.

Saber que cada segmento é, na verdade, um LED é a chave para entender os displays de 7 segmentos; para o básico, dê uma olhada em O que é LED? No app BlueGrays você encontra projetos de contagem de 0 a 9, contador com botão, dado, relógio digital de 4 dígitos e animação de bomba passo a passo, com esquemas do circuito e código.