Como configurar displays de 7 segmentos no Arduino

Os displays de sete segmentos são usados em muitos dispositivos de consumo do dia a dia, como fornos de microondas, máquinas de lavar e condicionadores de ar. Eles são uma maneira simples, mas eficaz, de exibir dados numéricos, como tempo ou quantidade. Como são feitos de LEDs, são uma opção de baixo custo para exibição de informações.

Neste guia, mostrarei como configurar e programar displays de um e vários dígitos de sete dígitos em um Arduino.

As telas de sete segmentos vêm em uma ampla variedade de tamanhos e cores. Vermelho, azul e verde são as cores mais fáceis de encontrar. Os tamanhos variam de telas pequenas de 0,56 polegadas a telas grandes de 4 polegadas e até 6,5 polegadas. Alguns monitores têm um único dígito e outros dois ou quatro.

Antes de começarmos a trabalhar com 7 displays de segmento, precisamos entender algumas noções básicas de LEDs e como controlá-los.

Noções básicas de LED

Um único LED consiste em dois terminais, um ânodo e um cátodo. O ânodo é o terminal positivo e o cátodo é o terminal negativo:

Para alimentar o LED, conecte o cátodo ao terra e o ânodo à fonte de tensão. O LED pode ser ligado ou desligado alternando a energia no ânodo ou no cátodo.

Ânodo para GPIO

Com o ânodo do LED conectado a um pino digital, o cátodo é conectado ao terra:

Nota: Todos os LEDs precisam de um resistor limitador de corrente colocado no lado do ânodo ou no lado do cátodo para impedir que o LED se queime. O valor do resistor determinará o brilho do LED. 1K ohms é um bom ponto de partida, mas você pode calcular o valor ideal com uma calculadora de resistores de LED.

Para acender um LED com o ânodo conectado a um pino digital, defina-o como ALTO:

void setup(){
    pinMode(7, OUTPUT);
    digitalWrite(7, HIGH);
}

void loop(){ 
}

No bloco void setup(), configuramos o pino 7 do GPIO como uma saída com pinMode(7, OUTPUT); e aumente a velocidade com digitalWrite(7, HIGH);.

Cátodo para GPIO

Com o cátodo de um LED conectado a um pino digital, o ânodo é conectado ao Vcc. Para ligar o LED, o pino digital é comutado LOW, o que completa o circuito para o terra:

Neste caso, dirigimos o pino GPIO 7 LOW com digitalWrite(7, LOW);. Isso fecha o circuito e permite que a corrente flua de Vcc para o terra:

void setup(){
    pinMode(7, OUTPUT);
    digitalWrite(7, LOW);
}

void loop(){ 
}

Como as telas de 7 segmentos funcionam

Os displays de sete segmentos consistem em 7 LEDs, chamados segmentos, dispostos no formato de um “8”. A maioria dos displays de 7 segmentos possui 8 segmentos, com um ponto no lado direito do dígito que serve como ponto decimal. Cada segmento é nomeado com uma letra A a G e DP para o ponto decimal:

Cada segmento da tela pode ser controlado individualmente, como um LED comum.

Existem dois tipos de displays de 7 segmentos – cátodo comum e ânodo comum.

Displays de cátodo comuns

Em telas comuns de cátodo, todos os cátodos são conectados ao terra e os segmentos individuais são ligados e desligados alternando a energia para os ânodos:

Telas de ânodo comuns

Em telas comuns de ânodo, todos os ânodos são conectados ao Vcc e segmentos individuais são ligados e desligados alternando a energia para os cátodos:

Conectando monitores de 7 segmentos ao Arduino

As telas de um dígito e sete segmentos geralmente têm 10 pinos. Dois pinos se conectam ao terra e os outros 8 se conectam a cada um dos segmentos. Aqui está um diagrama de pinos do popular display de catodo comum 5161AS:

Antes de conectar seu monitor ao Arduino, você precisa saber se é ânodo comum ou cátodo comum e quais pinos se conectam a cada segmento. Essas informações devem constar na folha de dados, mas se você não encontrar a folha de dados ou não souber o número de peça de sua tela, mostrarei como descobrir isso abaixo …

Como saber se você tem um ânodo comum ou exibição de cátodo comum

Para determinar se um monitor é ânodo comum ou cátodo comum, você pode testar os pinos com um circuito de teste construído desta maneira:

Conecte o fio terra (preto) a qualquer pino da tela. Em seguida, insira o fio positivo (vermelho) em cada um dos outros pinos. Se nenhum segmento acender, mova o fio terra para outro pino e repita o processo. Faça isso até que pelo menos um segmento acenda.

Quando o primeiro segmento acender, deixe o fio terra onde está e conecte o fio positivo a cada um dos outros pinos novamente. Se um segmento diferente acender com cada pino diferente, você terá uma exibição de cátodo comum. O pino conectado ao fio terra é um dos pinos comuns. Deve haver dois deles.

Se dois pinos diferentes acenderem o mesmo segmento, você terá uma exibição em ânodo comum. O pino conectado ao fio positivo é um dos pinos comuns. Agora, se você conectar o fio terra a cada um dos outros pinos, deverá ver que um segmento diferente acende com cada pino diferente.

Como determinar a pinagem para sua exibição

Agora desenhe um diagrama mostrando os pinos em sua tela. Com o pino comum conectado ao fio terra (cátodo comum) ou positivo (ânodo comum), apalpe cada pino com o outro fio. Quando um segmento acender, anote o nome do segmento (A-G ou DP) ao lado do pino correspondente no seu diagrama.

Conectando monitores de um dígito ao Arduino

Depois de descobrir o layout dos pinos, conectar a tela a um Arduino é muito fácil. Este diagrama mostra como conectar um display 5161AS de um dígito (observe o resistor limitador de corrente de 1K ohm conectado em série com os pinos comuns):

Nos programas de exemplo abaixo, os pinos do segmento se conectam ao Arduino de acordo com esta tabela:

Programação de displays de um dígito

Instale a biblioteca

Usaremos uma biblioteca chamada SevSeg para controlar a exibição. A biblioteca SevSeg funciona com monitores de um e vários dígitos, com sete dígitos. Você pode baixar o arquivo ZIP da biblioteca no GitHub:

Para instalá-lo, abra o IDE do Arduino, vá para Sketch -> Incluir biblioteca -> Adicionar biblioteca .ZIP e selecione o arquivo ZIP do SevSeg que você baixou.

Imprimir números no visor

Este programa imprimirá o número “4” em um display de 7 segmentos com um dígito:

#include "SevSeg.h"
SevSeg sevseg; 

void setup(){
    byte numDigits = 1;
    byte digitPins[] = {};
    byte segmentPins[] = {6, 5, 2, 3, 4, 7, 8, 9};
    bool resistorsOnSegments = true;

    byte hardwareConfig = COMMON_CATHODE; 
    sevseg.begin(hardwareConfig, numDigits, digitPins, segmentPins, resistorsOnSegments);
    sevseg.setBrightness(90);
}

void loop(){
        sevseg.setNumber(4);
        sevseg.refreshDisplay();        
}

Neste programa, criamos um objeto sevseg na linha 2. Para usar exibições adicionais, você pode criar outro objeto e chamar as funções relevantes para esse objeto. A exibição é inicializada com a função sevseg.begin() na linha 11. As outras funções são explicadas abaixo:

hardwareConfig = COMMON_CATHODE; Isso define o tipo de exibição. Estou usando um cátodo comum, mas se você estiver usando um ânodo comum, use COMMON_ANODE.

byte numDigits = 1; Isso define o número de dígitos no seu visor. Estou usando uma tela de um dígito, então defino-a como 1. Se você estiver usando uma tela de quatro dígitos, defina-a como 4.

byte digitPins[] = {}; Cria uma matriz que define os pinos de aterramento ao usar um display de 4 ou vários dígitos. Deixe em branco se você tiver uma tela de um dígito. Por exemplo, se você tem uma tela de 4 dígitos e deseja usar os pinos 10, 11, 12 e 13 do Arduino como pinos de aterramento, deve usar isso: byte digitPins [] = {10, 11, 12, 13}; . Veja o exemplo de exibição de 4 dígitos abaixo para obter mais informações.

segmento de bytesPins[] = {6, 5, 2, 3, 4, 7, 8, 9}; Isso declara uma matriz que define quais pinos do Arduino estão conectados a cada segmento da tela. A ordem é alfabética (A, B, C, D, E, F, G, DP, onde DP é o ponto decimal). Portanto, neste caso, o pino 6 do Arduino se conecta ao segmento A, o pino 5 se conecta ao segmento B, o pino 2 se conecta ao segmento C e assim por diante.

resistorsOnSegments = true; Isso precisa ser definido como verdadeiro se os resistores limitadores de corrente estiverem em série com os pinos do segmento. Se os resistores estiverem em série com os pinos dos dígitos, defina-o como falso. Defina como true ao usar telas com vários dígitos.

sevseg.setBrightness(90); Esta função define o brilho da tela. Pode ser ajustado de 0 a 100.

sevseg.setNumber(); Esta função imprime o número no visor. Por exemplo, sevseg.setNumber (4); imprimirá o número “4” no visor. Você também pode imprimir números com pontos decimais. Por exemplo, para imprimir o número “4.999”, você usaria sevseg.setNumber (4999, 3) ;. O segundo parâmetro (o 3) define onde o ponto decimal está localizado. Nesse caso, são três dígitos do dígito mais à direita. Em uma exibição de um dígito, definir o segundo parâmetro como “0” ativa o ponto decimal, enquanto definir o “1” o desativa.

sevseg.refreshDisplay(); Esta função é necessária no final da seção do loop para continuar exibindo o número.

Temporizador de contagem

Este programa simples conta de zero a 9 e depois volta ao início:

#include "SevSeg.h"
SevSeg sevseg; 

void setup(){
    byte numDigits = 1;
    byte digitPins[] = {};
    byte segmentPins[] = {6, 5, 2, 3, 4, 7, 8, 9};
    bool resistorsOnSegments = true;

    byte hardwareConfig = COMMON_CATHODE; 
    sevseg.begin(hardwareConfig, numDigits, digitPins, segmentPins, resistorsOnSegments);
    sevseg.setBrightness(90);
}

void loop(){
    for(int i = 0; i < 10; i++){
        sevseg.setNumber(i, i%2);
        delay(1000);
        sevseg.refreshDisplay(); 
        }
}

O código é semelhante ao esboço anterior. A única diferença é que criamos uma variável de contagem “i” na instrução for na linha 16 e a incrementamos um número por vez.

O sevseg.setNumber(i, i% 2); A função imprime o valor de i. O argumento i% 2 divide i por 2 e retorna o restante, o que faz com que o ponto decimal seja ativado em qualquer outro número.

O cronômetro de contagem é uma ótima maneira de demonstrar o básico de como programar a exibição, mas agora vamos tentar tornar algo mais interessante.

Dados de rolamento

Este exemplo consiste em um botão e uma única exibição de 7 segmentos. Sempre que o botão é pressionado e pressionado, o visor percorre os números de 0 a 9 rapidamente. Depois que o botão é solto, o visor continua em loop por um período quase igual ao tempo em que o botão foi pressionado e, em seguida, exibe um número junto com o ponto decimal para indicar o novo número.

Para construir o circuito (com o monitor 5161AS), conecte-o assim:

Em seguida, faça o upload deste programa para o Arduino:

#include "SevSeg.h"
SevSeg sevseg;

const int  buttonPin = 10;    // o pino ao qual o botão está conectado
int buttonState = 0;          // estado atual do botão
int lastButtonState = LOW;    // estado anterior do botão
int buttonPushCounter = 0;    // contador para o número de pressionamentos de botão
long counter = 0;
long max_long_val = 2147483647L;

void setup(){
  byte numDigits = 1;
  byte digitPins[] = {};
  byte segmentPins[] = {6, 5, 2 , 3, 4 , 7, 8, 9};
  bool resistorsOnSegments = true; 

  byte hardwareConfig = COMMON_CATHODE;
  sevseg.begin(hardwareConfig, numDigits, digitPins, segmentPins, resistorsOnSegments);
  sevseg.setBrightness(90);

  pinMode(buttonPin, INPUT_PULLUP);
  Serial.begin(9600);
  lastButtonState = LOW;
}

void loop(){
  buttonState = digitalRead(buttonPin);
  if(buttonState == HIGH){
    buttonState = LOW;
    }

  else
   buttonState = HIGH;

  if(buttonState == HIGH){
     Serial.println("on");
     lastButtonState = HIGH;
     buttonPushCounter++;
     if(counter < max_long_val)
       counter++;
     buttonPushCounter %= 9;
     sevseg.setNumber(buttonPushCounter, 1);    
     sevseg.refreshDisplay();     
     delay(100 - (counter%99));
     }
  
  else{
     Serial.println("off");
     if(lastButtonState == HIGH){
       Serial.println("in");
       buttonPushCounter++;
       buttonPushCounter %= 7;
       if(buttonPushCounter == 0)
         buttonPushCounter = 1;
       counter--;
       sevseg.setNumber(buttonPushCounter, 1);    
       sevseg.refreshDisplay();
       delay(100 - (counter%99));
       if(counter == 0){
         lastButtonState = LOW;
         sevseg.setNumber(buttonPushCounter, 0);
         sevseg.refreshDisplay();         
       }
     }
  }
}

Displays de 4 dígitos e 7 segmentos

Até agora, trabalhamos apenas com monitores de 7 segmentos de um dígito. Para exibir informações como hora ou temperatura, convém usar uma tela de 2 ou 4 dígitos ou conectar várias telas de um dígito lado a lado.

Em telas com vários dígitos, um pino de segmento (A, B, C, D, E, F, G e DP) controla o mesmo segmento em todos os dígitos. Os displays de vários dígitos também possuem pinos comuns separados para cada dígito. Estes são os pinos dos dígitos. Você pode ativar ou desativar um dígito, alternando o pino do dígito.

Estou usando um display de 4 dígitos e 7 segmentos com o número do modelo 5641AH, mas os diagramas de fiação abaixo também funcionarão com o 5461AS.

Aqui está um diagrama mostrando a pinagem dessas telas:

Os pinos dos dígitos D1, D2, D3 e D4 precisam ser conectados aos resistores limitadores de corrente, pois são os terminais comuns dos dígitos. As conexões são mostradas abaixo:

Este programa simples imprime o número “4.999” no visor:

#include "SevSeg.h"
SevSeg sevseg; 

void setup(){
  byte numDigits = 4;
  byte digitPins[] = {10, 11, 12, 13};
  byte segmentPins[] = {9, 2, 3, 5, 6, 8, 7, 4};

  bool resistorsOnSegments = true; 
  bool updateWithDelaysIn = true;
  byte hardwareConfig = COMMON_CATHODE; 
  sevseg.begin(hardwareConfig, numDigits, digitPins, segmentPins, resistorsOnSegments);
  sevseg.setBrightness(90);
}

void loop(){
    sevseg.setNumber(4999, 3);
    sevseg.refreshDisplay(); 
}

No código acima, definimos o número de dígitos na linha 5 com byte numDigits = 4;.

Como os displays de vários dígitos usam pinos de dígitos, também precisamos definir quais pinos do Arduino se conectarão aos pinos de dígitos. Usando o byte digitPins[] = {10, 11, 12, 13}; na linha 6 define o pino 10 do Arduino como o primeiro dígito, o pino 11 do Arduino no pino do segundo dígito e assim por diante.

Para imprimir números com um ponto decimal, definimos o segundo parâmetro em sevseg.setNumber(4999, 3); para três, o que coloca três casas decimais do dígito mais à direita.

Indicador de temperatura

Este exemplo lê a temperatura de um termistor e a exibe em um display de 4 dígitos.

Conecte o circuito assim:

Se você tiver dúvidas sobre o uso de um termistor ou apenas quiser saber mais sobre eles, consulte nosso outro tutorial sobre o uso de um termistor com um Arduino.

Depois que tudo estiver conectado, faça o upload deste código no Arduino:

#include "SevSeg.h"
SevSeg sevseg;

int ThermistorPin = 0;
int Vo;
float R1 = 10000;
float logR2, R2, T;
float c1 = 1.009249522e-03, c2 = 2.378405444e-04, c3 = 2.019202697e-07;

void setup() {
  byte numDigits = 4;
  byte digitPins[] = {10, 11, 12, 13};
  byte segmentPins[] = {9, 2, 3, 5, 6, 8, 7, 4};
  bool resistorsOnSegments = true;
  byte hardwareConfig = COMMON_CATHODE;

  sevseg.begin(hardwareConfig, numDigits, digitPins, segmentPins, resistorsOnSegments);
}

void loop() {
  Vo = analogRead(ThermistorPin);
  R2 = R1 * (1023.0 / (float)Vo - 1.0);
  logR2 = log(R2);
  T = (1.0 / (c1 + c2 * logR2 + c3 * logR2 * logR2 * logR2));
  T = T - 273.15;
  T = (T * 9.0) / 5.0 + 32.0; //Comment out for Celsius

  static unsigned long timer = millis();

  if (millis() >= timer) {
    timer += 300;
    sevseg.setNumber(T, 2);
  }

  sevseg.refreshDisplay();
}

Isso produzirá a temperatura em Fahrenheit. Para exibir a temperatura em graus Celsius, comente a linha 28.

Por si só, a tela será atualizada sempre que a temperatura mudar, mesmo que ligeiramente. Isso cria uma cintilação irritante. Para lidar com isso, introduzimos um mecanismo de timer, onde apenas lemos o valor do termistor a cada 300 milissegundos (linhas 30 a 34).

A variável de temperatura “T” é impressa no visor na linha 35 com sevseg.setNumber(T, 2, false);.

Esperamos que este artigo seja suficiente para você começar a usar sete displays de segmento. Se você deseja exibir leituras de outros sensores, o programa de exemplo acima pode ser facilmente modificado para fazer isso. Se você tiver alguma dúvida ou dificuldade em instalar esses circuitos, fique à vontade para deixar um comentário abaixo.

 

Esperamos que você tenha gostado deste guia mostrando com usar o Display de Sete Segmentos.

Obrigado pela leitura