Mostrando postagens com marcador display 7 segmentos. Mostrar todas as postagens
Mostrando postagens com marcador display 7 segmentos. Mostrar todas as postagens

13 dezembro 2017

Como usar o módulo TM1637 com Arduino

Neste post vamos mostrar como utilizar o módulo TM1637 com Arduino. Você verá que é um módulo bem simples de usar, e que pode ser utilizado nas mais variadas situações.

Arduino e módulo TM1637

O TM1637 é um módulo que possui um display de 7 segmentos e 4 dígitos, utilizando somente 2 pinos de conexão ao microcontrolador. Além da utilização como contador, também é um display perfeito para montar um relógio com Arduino, já que o display conta com os "2 pontos" na parte central.

30 setembro 2016

Contador com módulo display 4 dígitos 74HC595

O módulo display 4 dígitos 74HC595 é um módulo que usa 4 displays de 7 segmentos, onde podemos mostrar números e letras, e que usa apenas 3 pinos para conexão ao microcontrolador.

Contador com módulo display 4 dígitos 74HC595


Neste post vamos usar o módulo 74HC595 para montar um contador com 2 push-buttons, que você pode usar como base para montar seu próprio projeto.

21 agosto 2016

CD4511 com Arduino e display 7 segmentos

Aqui no blog você já viu como controlar um display 7 segmentos com o Max7219 e também como ligar um display 7 segmentos diretamente nas portas do Arduino. Neste post vamos usar o CI decodifficador CD4511 para fazer esse controle junto com o Arduino.

CD4511 com Arduino


O CD4511 usa somente 4 portas do Arduino, tornando o circuito mais simples (principalmente na conexão com o microcontrolador) e deixando as outras portas livres para uso de outros componentes como sensores, atuadores, módulos, etc.

21 janeiro 2015

Contador com botão de reset

Recebi alguns pedidos aqui no blog sobre contadores com botão de reset. No post Contador Display 7 segmentos - 3 dígitos, por exemplo, o contador era incrementado cada vez que o sensor óptico TCRT5000 era acionado, mas para zerar o contador era preciso reiniciar o Arduino.

Vou mostrar nesse post como implementar facilmente esse botão de reset do contador em dois circuitos : um utilizando display 7 segmentos de 3 dígitos, e outro utilizando um display LCD 16x2.

14 outubro 2014

Módulo display 7 segmentos 8 dígitos com MAX7219

Uma sugestão de módulo para quem precisa utilizar display 7 segmentos sem ter que ligar um monte de fios, é esse módulo display 7 segmentos de 8 dígitos, com CI MAX7219.

display 7 segmentos 8 digitos max7219

Como você pode ver pela imagem, podemos imprimir alguns caracteres nesse display além, é claro, de mostrar os números. Uma outra maneira de acionar o display, que veremos adiante, é utilizar uma sequência de bits para acionar os segmentos correspondentes no display e criarmos nossos próprios símbolos.

Aqui no Arduino e Cia já usamos o MAX7219 para controlar tanto módulos matriz de leds 8x8 como displays 7 segmentos :


O funcionamento do módulo de 8 dígitos é muito semelhante ao que vimos nesses posts, pois ele também usa apenas três pinos (lado esquerdo) para conexão ao Arduino ou outro microcontrolador

No lado direito, encontramos os pinos que permitem a ligação de vários módulos em cascata :

Módulo display 7 segmentos - pinagem



O circuito para ligação ao Arduino fica então dessa maneira, com os pinos 5, 6 e 7 conectados respectivamente aos pinos LOAD, CLK e DIN :

Circuito Arduino Uno - Display 7 segmentos Max7219



Programa utilizando a biblioteca LedControl

A biblioteca LedControl, que pode ser baixada nesse link é quem vai controlar o acionamento do display. Comandos principais do LedControl utilizados no programa :

LedControl lc=LedControl(7, 6, 5 , 1) = Define os pinos que serão ligados ao módulo. Pino 7 do Arduino ao DIN, pino 6 ao CLK e pino 5 ao LOAD. O último valor se refere à quantidade de módulos que estão conectados ao Arduino.

lc.shutdown(0, false) = Esse comando, além de servir para inicializar o display, também serve para apagar o display sem perder os dados em memória. Esse comando é especialmente útil quando o módulo estiver sendo alimentado por baterias, já que podemos mostrar os dados no display apenas quando for acionado um botão, por exemplo. Nesse caso, basta alterar o último parâmetro para TRUE quando não quisermos que o display permaneça ligado.

lc.setIntensity(modulo, valor) = Regula o brilho do display. O primeiro parâmetro é o número do módulo, e valor pode ser um número entre 0 (mínimo) à 15 (brilho máximo).

lc.setChar(modulo, digito, caracter, false) = Imprime um caracter no display. Apesar de não termos muitos caracteres disponíveis devido à limitação do display de 7 segmentos, podemos utilizar os caracteres A, B, C, D, E, F, H, L e P.

lc.setDigit(modulo, digito, valor, ponto_decimal) = Utilizamos para enviar diretamente um número ou o valor de uma variável para determinado digito no display. O parâmetro ponto_decimal pode receber os valores TRUE (exibe o ponto decimal), ou FALSE (desativa o ponto decimal).

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
// Programa : Display 7 segmentos - 8 digitos MAX7219
// Autor : Arduino e Cia

// Carrega a biblioteca LedControl
#include "LedControl.h"

// Definicoes dos pinos e quantidade de modulos no circuito
LedControl lc=LedControl(7,6,5,1);

void setup() 
{
  // Inicializa o modulo
  lc.shutdown(0,false);
  // Ajuste do brilho do display
  lc.setIntensity(0,3);
  // Apaga o display
  lc.clearDisplay(0);
}

void loop()
{
  // Envia Arduino e Cia para o display
  writeArduinoOn7Segment();
  // Contagem regressiva
  contagem_regressiva();
  // Mostra numeros no lado esquerdo e direito do display
  numeros_separados();
  // Inicia contador de 0 a 1 milhao
  for (long i=0; i < 1000000; i++)
  {
    printNumber(i);
  }
  delay(500);
}
void printNumber(long v) 
{
  // Variavel valor digitos
  int digito1;
  int digito2;
  int digito3;
  int digito4;
  int digito5;
  int digito6;
  int digito7;
  int digito8;

  // Calcula o valor de cada digito
  digito1 = v%10;
  digito2 = (v / 10) % 10;
  digito3 = (v/ 100) % 10;  
  digito4 = (v/1000) %10;
  digito5 = (v/10000) %10;
  digito6 = (v/100000) %10;
  digito7 = (v/1000000) %10;
  digito8 = (v/10000000) %10;
  
  // Mostra o valor de cada digito no display
  lc.setDigit(0,7,(byte)digito8,false);
  lc.setDigit(0,6,(byte)digito7,false);
  lc.setDigit(0,5,(byte)digito6,false);
  lc.setDigit(0,4,(byte)digito5,false);
  lc.setDigit(0,3,(byte)digito4,false);
  lc.setDigit(0,2,(byte)digito3,false);
  lc.setDigit(0,1,(byte)digito2,false);
  lc.setDigit(0,0,(byte)digito1,false);
  delay(00);
}

void writeArduinoOn7Segment() 
{
  // Escreve Arduino e Cia no display
  for (int i =0; i<21; i++)
  {
    lc.setChar(0,i,'a',false);
    lc.setRow(0,i-1,0x05);
    lc.setChar(0,i-2,'d',false);
    lc.setRow(0,i-3,0x1c);
    lc.setRow(0,i-4,B00010000);
    lc.setRow(0,i-5,0x15);
    lc.setRow(0,i-6,0x1D);
    lc.setChar(0,i-7,' ',false);
    lc.setChar(0,i-8,'e',false);
    lc.setChar(0,i-9,' ',false);
    lc.setRow(0,i-10,B1001110);    
    lc.setRow(0,i-11,B0010000);  
    lc.setChar(0,i-12,'a',false);    
    lc.setChar(0,i-13,' ',false);
    delay(300);
  }
}

void contagem_regressiva()
{
  for (int x = 8; x >-1;x--)
  {
    lc.setDigit(0,x,x+1, false);
    lc.setChar(0,x+1,' ',false);
    delay(300);
  }
  lc.clearDisplay(0);
} 

void numeros_separados()
{
  for (int i =0 ; i<10 ; i++)
  {
     lc.setDigit(0,0,i,false);
     lc.setDigit(0,1,i,false);
     lc.setDigit(0,6,i,false);
     lc.setDigit(0,7,i,false);
     delay(300);
  }
  lc.clearDisplay(0);
}

Por último, para acionar apenas determinados segmentos do display, usamos o comando lc.setRow(), que tem a seguinte sintaxe :

lc.setRow(numero_modulo, digito,  valor) = Podemos definir valor em decimal, hexa ou binário, mas o comando fica mais fácil de entender se utilizarmos binário.

Veja por exemplo a letra "R", que escrevemos no display usando esse comando :

lc.setRow(0, digito, 0x05)

Em binário, o comando fica assim :

lc.setRow(0, digito, B00000101)

Que significa que estamos acionando apenas os segmentos E e G do display. A figura abaixo mostra exatamente como isso funciona :

Display 7 segmentos - Binario

Escolha os segmentos que você deseja ligar ou desligar, alterando o valor do bit correspondente para 1 ou 0.

Abaixo, vídeo mostrando o funcionamento do programa listado acima :



19 outubro 2013

Contador Display 7 segmentos - Video

Olá ! Conforme comentei, segue abaixo vídeo demonstrando o funcionamento do contador com display 7 segmentos de 3 dígitos, que abordei no artigo anterior :



15 outubro 2013

Contador Display 7 segmentos - 3 dígitos

Quem quer iniciar com o Arduino geralmente fica em dúvida sobre quais componentes comprar. Eu mesmo comprei algumas coisas que não usei até hoje... :-)

Pensando nisso, a FILIPEFLOP , parceira aqui do site, criou kits de componentes com tudo o que você precisa para montar seus primeiros experimentos. O kit básico, por exemplo, vem com o Arduino Uno, sensor ultrasonico, relé, push-button, leds, protoboard, jumpers, display LCD, fonte, potenciômetro, display 7 segmentos...e muito mais. Dê uma olhada nesse link e veja todos os kits disponíveis.

E falando em kit, no último artigo eu abordei o sensor óptico TCRT5000, mostrando o acionamento de um led com a aproximação de um objeto do sensor óptico, e hoje vou usar esse mesmo sensor óptico, mas juntamente com o display 7 segmentos 3 dígitos, que também vem no kit básico, para criar um contador.

O display 7 segmentos - 3 dígitos CPS03631BR é um display de anodo comum com 12 pinos, conforme mostrado no esquema abaixo (6 pinos na parte superior, 5 pinos na parte inferior, o pino 6 não é utilizado), e que você pode conferir no datasheet. São sete pinos para os segmentos A, B, C, D, E, F, G, um pino para o ponto decimal (DP), e um pino para cada dígito :

contador display 7 segmentos

Em um display 7 segmentos de apenas um dígito, é possível deixar o anodo sempre em estado alto, e ir acionando os segmentos conforme a necessidade, formando os  números. Nesse display de 3 dígitos, se eu deixar todos os anodos em estado alto, vou mostrar os mesmo números em todos os dígitos.

Como eu evito isso ? Usando um procedimento chamado multiplexação, que consiste no seguinte : aciono o anodo do dígito 1, e ligo os segmentos desejados, desligo o anodo do digito 1, ligo o anodo do digito 2 e aciono os segmentos desejados, e faço o mesmo procedimento com o digito 3, e depois repito o processo. Desta forma, uso os mesmo pinos do Arduino para a ativação dos segmentos de todos os dígitos. Dê uma olhada nessa animação abaixo, que mostra como isso acontece :

Animação multiplexação display 7 segmentos
Mostrando assim, parece que o display vai "piscar", não é mesmo ? Mas o segredo é fazer isso numa frequencia tão alta que o olho humano nem vai perceber, devido à um fenômeno conhecido como persistência da visão.

Antes de entrar na parte do circuito e do programa, gostaria de fazer um parênteses sobre a parte eletrônica. Eu verifiquei vários tutoriais e artigos diferentes, que mostram displays com 2 ou mais dígitos. Em alguns deles , são usadas resistências para ligar os pinos do Arduino diretamente ao anodo dos dígitos. Outros utilizam transistores, para não sobrecarregar e/ou ultrapassar a corrente máxima suportada pelo Arduino. Eu utilizei apenas um resistor de 1K em cada ligação dos anodos. Também liguei diretamente os pinos do Arduino aos pinos dos segmentos do display. Isso talvez reduza a vida útil do display, então recomendo que, dependendo da aplicação, esse procedimento seja revisto.

Vamos então à lista de materiais que utilizei :
  • 3 resistores de 1 K (um para cada dígito/anodo)
  • 1 resistor de 220 ohms (led IR do sensor óptico)
  • 1 resistor de 10 k (ligado ao sensor óptico - receptor)
  • Display 7 segmentos de 3 dígitos CPS03631BR
  • Sensor óptico reflexivo TCRT5000
Circuito contador com sensor óptico

Achei na internet vários exemplos de códigos usando multiplexação, e até criei um próprio (que não funcionou muito bem, diga-se de passagem), mas no final acabei utilizando a biblioteca SevSeg , que faz todo o serviço pesado : basta definir qual informação você quer mandar para o display (nesse programa exemplo, a varíavel CONTADOR), e a biblioteca faz o resto :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
// Programa : Contador utilizando display 7 segmentos e TCRT5000  
// Alterações e adaptações : Arduino e Cia  
//  
// Baseado no exemplo da biblioteca SevSeg, de Dean Reading  
// [email protected]  
   
#include "SevSeg.h" //Carrega a biblioteca SevSeg  
   
SevSeg sevseg;  
   
//Cria variaveis globais  
int contador = 0;  

//Ligado ao pino "coletor" do sensor óptico - Porta A5 ao Arduino  
int pinosensor = 19; 
int leitura; //Armazena o valor lido pelo sensor  
   
void setup() 
{  
  //Utilizando display de anodo comum, pinos dos digitos : 10 a 13  
  //Pino dos segmentos : 2 a 9  
  sevseg.Begin(1,13,10,11,12,2,3,4,5,6,7,8,9);  
  //Controla a luminosidade - 0 a 100  
  sevseg.Brightness(20);  
  //Define o pino do sensor optico como entrada 
  pinMode(pinosensor, INPUT);  
}  
   
void loop() 
{  
  //Produce an output on the display  
  sevseg.PrintOutput();  
  sevseg.NewNum(contador,(byte) 2);

  //Le as informações do pino do sensor  
  leitura = digitalRead(pinosensor);   
  if (leitura != 1) //Verifica se o objeto foi detectado  
  {  
    contador = contador++; //Incrementa o valor do contador  

    //Loop caso o objeto pare sobre o sensor 
    while(digitalRead(pinosensor) != 1)  
    {  
      sevseg.PrintOutput();  
     sevseg.NewNum(contador,(byte) 2);  
    }  
  }   
}  

Se você precisa de um botão de reset para zerar o contador, veja o artigo Contador com botão de reset, aqui mesmo no Arduino e Cia.

Em breve publicarei um vídeo mostrando o funcionamento desse circuito. Até lá !

Atualizado : Contador Display 7 segmentos - Vídeo


27 julho 2013

Controlando 2 displays 7 segmentos com Max7219

No primeiro artigo sobre o display 7 segmentos, vimos como ligar um display diretamente no Arduino. No segundo artigo, ligamos o display à um CI controlador de displays, o Max7219, que por sua vez se comunica com o Arduino utilizando apenas 3 portas da placa.

Neste terceiro artigo, vou continuar utilizando o CI Max7219 e usá-lo para controlar 2 displays de 7 segmentos, gerando o resultado abaixo :



Observe no circuito abaixo que a ligação ao segundo display é a mesma, ou seja, os mesmos fios que usei para ligar o CI nos segmentos A,B,C, etc, serão utilizados para ligação aos segmentos A,B,C, etc do 2o. display.

Outra alteração no circuito é a ligação do pino D1 (pino 11 do Max7219) ao pino 8 (comum) do segundo display :

Circuito Max7219 e 2 displays 7 segmentos
Essas são as alterações no circuito, tirando uma eventual mudança na resistência, para controlar a corrente nos displays, e essa é a vantagem de usar um CI como o Max7219 : você controla até 8 displays de 7 segmentos, continua usando apenas uma resistência para controlar a corrente em todos os displays, e o resto do "serviço" é feito pelo programa do Arduino.

E falando em programa, vou utilizar praticamente o mesmo do artigo anterior, fazendo um contador de 0 a 99. A mudança no programa está na linha que envia os dados para o display, com o comando lc.setdigit, que tem a seguinte sintaxe :

lc.setDigit( numero_do_chip, display , valor , pontodecimal )

numero_do_chip = Podemos usar até 8 chips MAX7219 em cascata, e esse número determina para qual chip estamos enviando os dados. Para o primeiro chip, o valor deste parametro será 0, para o segundo chip, o valor será 1, e assim sucessivamente.

display = é o número do display com o qual estamos trabalhando. O valor 0 envia os dados para o primeiro display, o valor 1 envia para o segundo display, e assim sucessivamente

valor = é o valor a ser mostrado no display selecionado

pontodecimal = Recebe o valor "true" se quisermos ligar o ponto decimal do display selecionado, ou "false" se quisermos desligá-lo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
// Programa : Controlando 2 displays 7 segmentos usando CI Max7219
// Alteracoes / comentarios  : Arduino e Cia
// Baseado no programa exemplo da biblioteca LedControl

#include "LedControl.h" 

// Pino 4 do Arduino ao pino 1 (DIN) do CI
// Pino 5 do Arduino ao pino 13 (CLK) do CI
// Pino 6 do Arduino ao pino 12 (LOAD) do CI
// Ultimo parametro se refere a qtde de MAX7219 utilizados no circuito
LedControl lc=LedControl(4,5,6,1); 

boolean pontodecimal; 

void setup() 
{ 
  // Inicializa o Max7219
  lc.shutdown(0,false); // Habilita o display 
  // Define o nivel de luminosidade (0 minimo, 15  maximo)
  lc.setIntensity(0,10); 
  lc.clearDisplay(0); // Apaga o display
  Serial.begin(9600); // Inicializa a serial
  pontodecimal = false;  //Define o ponto decimal como DESLIGADO
} 

void loop() 
{ 
  for(int i=0; i < 100 ; i++)  //Loop variando valor de i de 0 a 99
  { 
    //Mostra o valor de i/10 no display 1
    lc.setDigit(0,0,i/10,pontodecimal);  
    //Inverte o estado do ponto decimal
    pontodecimal = !pontodecimal;   
    //Mostra o valor de i%10 no display 2
    lc.setDigit(0,1,i%10,pontodecimal);  
    Serial.println(i);
    delay(1000);  //Aguarda 1 segundo e mostra o próximo valor
  } 
delay(1000);  //Aguarda 1 segundo e reinicia a contagem
}

22 julho 2013

Controlando display 7 segmentos com o Max7219

Continuando o assunto display 7 segmentos, abordado no meu post anterior, hoje vou controlar o display 7 segmentos usando o CI MAX7219, fabricado pela Maxim.

Arduino - CI Max7219 - Display 7 segmentos


O Max7219 é um CI driver display, isto é, um controlador feito especialmente para trabalhar com displays, tanto os de 7 segmentos, como as matrizes de led. Ele trabalha com displays de catodo comum e a comunicação com o Arduino utiliza apenas 3 portas da placa (veja que no exemplo do post anterior, eu usei 8 portas).

Além disso, com um único chip MAX7219 é possível controlar até 8 displays de 7 segmentos utilizando as mesmas 3 portas do Arduino. Outra vantagem é o uso de apenas um resistor para todos os segmentos, entre os pinos 19 e 18, conforme mostra o datasheet do CI :


A montagem do circuito requer atenção para não danificar o CI. Repare que o "chanfro" fica do lado esquerdo, logo o pino 1 fica à esquerda, abaixo do CI. Observe a pinagem do Max7219 :


Ligamos os pinos SEG A, SEG B,etc. , aos pinos do display, segmentos A, B, C, etc. Como neste exemplo temos apenas 1 display, vamos ligar o comum - pino 8 - ao pino DIG 0 do CI. Siga a tabela abaixo :




Para o programa exemplo, vamos utilizar a biblioteca LedControl, que você pode encontrar aqui, ou nesse link :

http://www.wayoda.org/arduino/downloads/LedControl.zip

Instalada a biblioteca, carregue o seguinte programa no Arduino :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
// Programa : Contador display 7 segmentos usando CI Max7219
// Alteracoes / comentarios  : Arduino e Cia
// Baseado no programa exemplo da biblioteca LedControl

#include "LedControl.h" //Carrega a biblioteca LedControl

// Pino 4 do Arduino ao pino 1 (DIN) do CI
// Pino 5 do Arduino ao pino 13 (CLK) do CI
// Pino 6 do Arduino ao pino 12 (LOAD) do CI
// Ultimo parametro se refere a qtde de MAX7219 no circuito

LedControl lc=LedControl(4,5,6,1); 

boolean pontodecimal;  //Armazena o estado do ponto decimal (Lig/Desl)

void setup() 
{ 
  // Inicializa o Max7219
  lc.shutdown(0,false); // Habilita o display 
  // Define o nivel de luminosidade (0 minimo, 15  maximo)
  lc.setIntensity(0,10); 
  lc.clearDisplay(0); // Apaga o display
  Serial.begin(9600); // Inicializa a serial
  pontodecimal = true;  //Define o ponto decimal como LIGADO
} 

void loop() 
{ 
  for(int i=0; i < 10 ; i++)  //Loop variando valor de i de 0 a 9
  { 
    lc.setDigit(0,0,i,pontodecimal);  //Mostra o valor de i no display 
    Serial.println(i);
    pontodecimal = !pontodecimal; //Inverte o estado do ponto decimal
    delay(1000);  //Aguarda 1 segundo e mostra o próximo valor
  } 
delay(1000);  //Aguarda 1 segundo e reinicia a contagem
}

Este programa configura as portas a serem utilizadas com os pinos DIN, CLK e LOAD do CI, inicializa o display e mostra os valores de 0 a 9 por meio de um loop. Como costumo fazer, mostro também o valor no monitor serial, para fins de acompanhamento e análise caso ocorra algum problema na ligação do circuito.

No próximo artigo, vamos utilizar este circuito como base, e mostrar como utilizar esse CI para controlar 2 (ou mais) displays.

Atualizado : Controlando 2 displays de 7 segmentos com o Max7219

Até a próxima !



17 julho 2013

Display 7 segmentos

Hoje vou falar de outro display bastante comum utilizado nos projetos do Arduino : o display de 7 segmentos, como esse abaixo :

Display 7 segmentos FJ5101AH

O display de 7 segmentos, como o próprio nome diz, tem 7 partes, ou segmentos, que podem ser agrupados de modo a formar números e letras.

Display 7 segmentos - letras e numeros

Os segmentos são organizados de A a F :
Display 7 segmentos - Disposição dos segmentos
Imagem : Wikipedia
Assim, se você quiser mostrar o número 1, basta ativar os segmentos B e C. Para mostrar o número 3, os segmentos A, B, C, D e G, e assim por diante.

A ligação ao Arduino usa os pinos de 2 a 9, mais o GND,  na seguinte sequencia :

Pino 2 do Arduino ====> Pino segmento A
Pino 3 do Arduino ====> Pino segmento B
Pino 4 do Arduino ====> Pino segmento C
Pino 5 do Arduino ====> Pino segmento D
Pino 6 do Arduino ====> Pino segmento E
Pino 7 do Arduino ====> Pino segmento F
Pino 8 do Arduino ====> Pino segmento G
Pino 9 do Arduino ====> Pino segmento PONTO
Pino GND do Arduino => Pino 3 do display

Um ponto importante é a utilização dos resistores de 220 ohms para cada pino. Como o display trabalha com 2V, é necessário limitar a corrente, evitando queimar o componente :

Circuito Arduino Display 7 segmentosPara o modelo de display que estou utilizando (FJ5101AH, catodo comum), a disposição dos pinos é mostrada na próxima imagem. Se o seu display for de outro modelo, basta descobrir qual pino corresponde a cada segmento. Isso pode ser feito utilizando-se um multimetro ou até mesmo uma pilha, tomando o cuidado de respeitar a voltagem máxima que comentei acima : 2 volts.

Display catodo comum
Imagem : Parallax
Finalmente o programa, baseado no código desenvolvido pelo site hacktronics. Fiz algumas alterações no mesmo, para que o display mostre não só os números de 0 a 9, mas também as letras de A a F, em ordem crescente :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
// Programa : Contador crescente 0 a F
// Modificacoes e comentarios : Arduino e Cia
// Baseado no programa:
// Arduino 7 segment display example software
// http://www.hacktronics.com/Tutorials/arduino-and-7-segment-led.html
// License: http://www.opensource.org/licenses/mit-license.php (Go crazy)
// Define a ordem de ligação dos segmentos, dos digitos 0 a F
// Este padrão é para display de catodo comum
// Para display de anodo comum, modifique os valores de 0 para 1 e 
// de 1 para 0
// 1 = LED ligado, 0 = LED desligado, nessa ordem :
//                   Arduino pinos: 2,3,4,5,6,7,8

byte seven_seg_digits[16][7] = { { 1,1,1,1,1,1,0 },  // = Digito 0
                                 { 0,1,1,0,0,0,0 },  // = Digito 1
                                 { 1,1,0,1,1,0,1 },  // = Digito 2
                                 { 1,1,1,1,0,0,1 },  // = Digito 3
                                 { 0,1,1,0,0,1,1 },  // = Digito 4
                                 { 1,0,1,1,0,1,1 },  // = Digito 5
                                 { 1,0,1,1,1,1,1 },  // = Digito 6
                                 { 1,1,1,0,0,0,0 },  // = Digito 7
                                 { 1,1,1,1,1,1,1 },  // = Digito 8
                                 { 1,1,1,0,0,1,1 },  // = Digito 9
                                 { 1,1,1,0,1,1,1 },  // = Digito A
                                 { 0,0,1,1,1,1,1 },  // = Digito B
                                 { 1,0,0,1,1,1,0 },  // = Digito C
                                 { 0,1,1,1,1,0,1 },  // = Digito D
                                 { 1,0,0,1,1,1,1 },  // = Digito E
                                 { 1,0,0,0,1,1,1 }   // = Digito F
                                 };


void setup() 
{  
  pinMode(2, OUTPUT); //Pino 2 do Arduino ligado ao segmento A  
  pinMode(3, OUTPUT); //Pino 3 do Arduino ligado ao segmento B
  pinMode(4, OUTPUT); //Pino 4 do Arduino ligado ao segmento C
  pinMode(5, OUTPUT); //Pino 5 do Arduino ligado ao segmento D
  pinMode(6, OUTPUT); //Pino 6 do Arduino ligado ao segmento E
  pinMode(7, OUTPUT); //Pino 7 do Arduino ligado ao segmento F
  pinMode(8, OUTPUT); //Pino 8 do Arduino ligado ao segmento G
  pinMode(9, OUTPUT); //Pino 9 do Arduino ligado ao segmento PONTO
  writePonto(0);  // Inicia com o ponto desligado
}

void writePonto(byte dot)   //Funcao que aciona o ponto no display
{  
  digitalWrite(9, dot);
}

void sevenSegWrite(byte digit)  //Funcao que aciona o display
{
  byte pin = 2;

  //Percorre o array ligando os segmentos correspondentes ao digito
  for (byte segCount = 0; segCount < 7; ++segCount)  
  { 
    digitalWrite(pin, seven_seg_digits[digit][segCount]);
    ++pin;
  }
    writePonto(1);  //Liga o ponto
    delay(100);   //Aguarda 100 milisegundos
    writePonto(0);  //Desliga o ponto
}

void loop() 
{
  //Contador de 0 a 15, ligando os segmentos correspondentes
  //0 a 9 = liga os segmentos correspondentes aos numeros
  //10 a 15 = Forma as letras A,B,C,D,E,F
  for (byte count = 0; count < 16; count++)
  {
     delay(500);
     sevenSegWrite(count);
  }
  delay(4000);
}

Não encontrei o datasheet específico desse display FJ5101AH.Procurando modelos similares, encontrei as informações abaixo, que podem ser utilizadas como base :

Display 7 Segmentos - Pinagem e dimensões

Display 7 segmentos - Dados técnicos
No próximo artigo vou usar esse mesmo display de 7 segmentos com o Arduino, mas gerenciado por um circuito integrado específico para trabalhar com displays : o Max7219.

Atualizado : Controlando display 7 segmentos com o Max7219

Atualizado : Ligando 2 displays 7 segmentos ao Max7219

Até lá !