Contador de 0 A 9 com display de 7 segmentos

Olá pessoal!

No post de hoje vamos criar um contador incremental e decremental utilizando um display de 7 segmentos em conjunto com a placa UNO e botões. Este é um dos projetos que vocês encontrarão no novo kit da loja Casa da Robótica, o Kit Construindo o Jogo da Memória e + 20 Projetos, que foi desenvolvido em parceria com o Blog da Robótica. Foi um projeto preparado com carinho para aqueles que estão iniciando os estudos no mundo da programação, eletrônica e robótica.

A proposta do Kit Construindo o Jogo da Memória e + 20 Projetos é que você aprenda programação e eletrônica na prática. Para isso, o kit conta com mais de 100 peças e acompanha um material digital de apoio em que os projetos práticos são detalhados passo a passo, o que tornará sua inserção no mundo Maker muito mais fácil e divertida.

MATERIAIS NECESSÁRIOS

ESQUEMÁTICO DE LIGAÇÃO

Certifique-se que a sua placa UNO esteja desligada e monte o circuito abaixo utilizando o display de 7 segmentos, os botões, os resistores e os fios.

Ao montar seu circuito na protoboard preste atenção nos seguintes pontos:
• O display de 7 segmentos é do tipo cátodo comum, então os terminais comuns do mesmo devem ser conectados ao terra (GND);
• Os segmentos do display de 7 segmentos são nomeados de a a g, em sentido horário, a partir do segmento superior do componente;
• Em cada segmento do display vamos conectar um resistor de 220 Ω;
• Os segmentos encontram-se conectado as portas digitais da seguinte maneira: a = 13; b = 12; c = 11; d = 10; e = 9; f = 8; g = 7;
• O primeiro botão será usado para o incremento e deve ser conectado a uma resistência pull-down de 10 kΩ e a porta digital 2;
• O segundo botão será usado para o decremento e deve ser conectado a uma resistência pull-down de 10 kΩ e a porta digital 3.

ELABORANDO O CÓDIGO

Para melhor compreensão da lógica de programação desse código vamos aos seguintes passos:

1. Declarar as variáveis
Iniciaremos a programação declarando as variáveis correspondentes ao controle dos segmentos do display. Conforme o esquemático elétrico, atribuiremos a porta 13 a variável a; a porta 12 a variável b; a porta 11 a variável c; a porta 10 a variável d; a porta 9 a variável e; a porta 8 a variável f; a porta 7 a variável g.

Em seguida, devemos declarar a variável correspondente aos botões de incremento e decremento e suas leituras. A porta 2 será atribuída a variável b1Pin (botão de incremento). A variável leitura1, do tipo inteiro, será responsável por receber a leitura do estado do botão de incremento e a variável ultleitura1, também do tipo inteiro, será responsável por receber o valor da última leitura do botão de incremento.

A porta 3 deve ser atribuída a variável b2Pin (botão de decremento). A variável leitura2, do tipo inteiro, será responsável por receber a leitura do estado do botão de decremento e a variável ultleitura2, também do tipo inteiro, será responsável por receber o valor da última leitura do botão de decremento.
Deve ser declarada também a variável contador, do tipo inteiro.

2. Configurar as portas de entrada e saída e inicializar a comunicação serial
Na função setup configuraremos todos as variáveis conectadas aos segmentos do display 7 segmentos como saída, ou seja, as variáveis a, b, c, d, e, f e g devem ser configuradas como OUTPUT. Por sua vez, as variáveis b1Pin e b2Pin deve ser configurada como entrada (INPUT).
A comunicação serial será inicializada por meio da instrução: Serial.begin(9600);

3. Criar as funções dos números a serem exibidos no display 7 segmentos
Na programação deste Sketch precisamos criar funções que serão responsáveis por acionar os segmentos do display para que ele exiba números de 0 a 9.
Desta forma, vamos criar uma função para cada número. Cada função conterá a combinação de segmentos que devem ser acionados (colocados em nível alto) para que exiba o número desejado. Para formar um dígito é necessário acender os segmentos correspondentes. Na Tabela abaixo estão listados os segmentos que devem ser acionados para formação dos números de 0 a 9.

NÚMERO	SEQUÊNCIA
0	a, b, c, d, e, f
1	b, c
2	a, b, d, e, g
3	a, b, c, d, g
4	b, c, f, g
5	a, c, d, f, g
6	a, c, d, e, f, g
7	a, b, c
8	a, b, c, d, e, f, g
9	a, b, c, f, g

4. Realizar as leituras dos botões
Inicializaremos o loop com a leitura do botão incremental, variável b1Pin, e atribuir o resultado da leitura a variável leitura1. Isso será feito através da instrução leitura1=digitalRead(b1Pin);

Em seguida, realizaremos a leitura do botão decremental, variável b2Pin, e atribuir o resultado da leitura a variável leitura2. Isso será feito através da instrução leitura2=digitalRead(b2Pin);

5. Comparar o valor de leitura1 com ultleitura1 e de leitura2 com ultleitura1
Neste projeto precisamos saber quantas mudanças de estado dos botões incremental e decremental ocorreram. Para fazer essa detecção precisamos comparar o estado de leitura do botão com a leitura anterior.

6. Verificar o valor de contador
Utilizaremos a estrutura de controle de fluxo de seleção switch…case para comparar o valor armazenado na variável contador aos números especificados nos comandos cases. Quando o valor armazenado for igual ao caractere especificado no case, o código para exibição do número correspondente deve ser executado.

7. Imprimir na serial o valor de contador
Para ter um maior controle e comparar o valor armazenado na variável contador ao exibido no display 7 segmentos incluímos a instrução Serial.println(contador); para que seja exibido seu valor no monitor serial.

8. Comparar se o valor da variável contador é maior ou igual a 10 e se contador é menor ou igual a -1
Como estamos utilizando apenas um display de 7 segmentos apenas podemos exibir números de 0 a 9, desta forma precisamos limitar o valor de contador para sempre que atingir um valor maior ou igual a 10 e menor ou igual a -1 ele seja zerado. Para isso, utilizamos as seguintes instruções:

  if (contador >= 10) {//Se contador for maior ou igual a 10
    contador = 0;//Atribui 0 a contador
  }
  if (contador <= -1) {//Se contador for menor ou igual a -1
    contador = 9;//Atribui 9 a contador
  }

Com isso, o código deste projeto fica da seguinte forma:

/*
--- INCREMENTO E DECREMENTO - 0 A 9 DISPLAY 7SEG ---
====================================================
==    BLOG DA ROBOTICA - www.blogdarobotica.com   ==
====================================================
Autor: Carol Correia Viana
E-mail: contato@blogdarobotica.com
Facebook: facebook.com/blogdarobotica
Instagram:@blogdarobotica
YouTube: youtube.com/user/blogdarobotica
====================================================
==   CASA DA ROBOTICA - www.casadarobotica.com    ==
====================================================
Facebook: facebook.com/casadaroboticaoficial
Instagram:@casadarobotica
====================================================
*/


int a = 13;//Correspondente ao LED a
int b = 12;//Correspondente ao LED b
int c = 11;//Correspondente ao LED c
int d = 10;//Correspondente ao LED d
int e = 9;//Correspondente ao LED e
int f = 8;//Correspondente ao LED f
int g = 7;//Correspondente ao LED g
int b1Pin = 2;//Correspondente ao botão +
int b2Pin = 3;//Correspondente ao botão -
int leitura1 = 0;//Leitura do botão +
int leitura2 = 0;//Leitura do botão -
int ultleitura1 = 0;//Última leitura do botão +
int ultleitura2 = 0;//Última leitura do botão -
int contador = 0;//Correspondente ao contador

void setup()
{
  pinMode(a, OUTPUT);//Define a como saída
  pinMode(b, OUTPUT);//Define b como saída
  pinMode(c, OUTPUT);//Define c como saída
  pinMode(d, OUTPUT);//Define d como saída
  pinMode(e, OUTPUT);//Define e como saída
  pinMode(f, OUTPUT);//Define f como saída
  pinMode(g, OUTPUT);//Define g como saída
  pinMode(b1Pin, INPUT);//Define b1Pin como entrada
  pinMode(b2Pin, INPUT);//Define b2Pin como entrada
  Serial.begin(9600);//Inicia a comunicação serial 
}
//Função para escrever o nº zero
void zero() {
  digitalWrite(a, 1);
  digitalWrite(b, 1);
  digitalWrite(c, 1);
  digitalWrite(d, 1);
  digitalWrite(e, 1);
  digitalWrite(f, 1);
  digitalWrite(g, 0);
  delay(100);
}
//Função para escrever o nº um
void um() {
  digitalWrite(a, 0);
  digitalWrite(b, 1);
  digitalWrite(c, 1);
  digitalWrite(d, 0);
  digitalWrite(e, 0);
  digitalWrite(f, 0);
  digitalWrite(g, 0);
  delay(100);
}
//Função para escrever o nº dois
void dois() {
  digitalWrite(a, 1);
  digitalWrite(b, 1);
  digitalWrite(c, 0);
  digitalWrite(d, 1);
  digitalWrite(e, 1);
  digitalWrite(f, 0);
  digitalWrite(g, 1);
  delay(100);
}
//Função para escrever o nº três
void tres() {
  digitalWrite(a, 1);
  digitalWrite(b, 1);
  digitalWrite(c, 1);
  digitalWrite(d, 1);
  digitalWrite(e, 0);
  digitalWrite(f, 0);
  digitalWrite(g, 1);
  delay(100);
}
//Função para escrever o nº quatro
void quatro() {
  digitalWrite(a, 0);
  digitalWrite(b, 1);
  digitalWrite(c, 1);
  digitalWrite(d, 0);
  digitalWrite(e, 0);
  digitalWrite(f, 1);
  digitalWrite(g, 1);
  delay(100);
}
//Função para escrever o nº cinco
void cinco() {
  digitalWrite(a, 1);
  digitalWrite(b, 0);
  digitalWrite(c, 1);
  digitalWrite(d, 1);
  digitalWrite(e, 0);
  digitalWrite(f, 1);
  digitalWrite(g, 1);
  delay(100);
}
//Função para escrever o nº seis
void seis() {
  digitalWrite(a, 1);
  digitalWrite(b, 0);
  digitalWrite(c, 1);
  digitalWrite(d, 1);
  digitalWrite(e, 1);
  digitalWrite(f, 1);
  digitalWrite(g, 1);
  delay(100);
}
//Função para escrever o nº sete
void sete() {
  digitalWrite(a, 1);
  digitalWrite(b, 1);
  digitalWrite(c, 1);
  digitalWrite(d, 0);
  digitalWrite(e, 0);
  digitalWrite(f, 0);
  digitalWrite(g, 0);
  delay(100);
}
//Função para escrever o nº oito
void oito() {
  digitalWrite(a, 1);
  digitalWrite(b, 1);
  digitalWrite(c, 1);
  digitalWrite(d, 1);
  digitalWrite(e, 1);
  digitalWrite(f, 1);
  digitalWrite(g, 1);
  delay(100);
}
//Função para escrever o nº nove
void nove() {
  digitalWrite(a, 1);
  digitalWrite(b, 1);
  digitalWrite(c, 1);
  digitalWrite(d, 1);
  digitalWrite(e, 0);
  digitalWrite(f, 1);
  digitalWrite(g, 1);
  delay(100);
}


void loop()
{
  leitura1 = digitalRead(b1Pin);//Lê o estado de b1Pin e armazena em leitura1
  leitura2 = digitalRead(b2Pin);//Lê o estado de b2Pin e armazena em leitura2
  if (leitura1 != ultleitura1) {//Se leitura1 não for igual a ultleitura1
    if (leitura1 == HIGH) {//Se leitura1 for igual a HIGH
      contador++;//Incrementa contador em 1
    }
  }
  ultleitura1 = leitura1;//Atribui a ultleitura1 o conteúdo de leitura1

  if (leitura2 != ultleitura2) {//Se leitura2 não for igual a ultleitura2
    if (leitura2 == HIGH) {//Se leitura2 for igual a HIGH
      contador--;//Decrementa contador em 1
    }
  }
  ultleitura2 = leitura2;//Atribui a ultleitura2 o conteúdo de leitura2

  switch (contador) {
    case 0:
      zero();//Executa a função zero
      break;
    case 1:
      um();//Executa a função um
      break;
    case 2:
      dois();//Executa a função dois
      break;
    case 3:
      tres();//Executa a função três
      break;
    case 4:
      quatro();//Executa a função quatro
      break;
    case 5:
      cinco();//Executa a função cinco
      break;
    case 6:
      seis();//Executa a função seis
      break;
    case 7:
      sete();//Executa a função sete
      break;
    case 8:
      oito();//Executa a função oito
      break;
    case 9:
      nove();//Executa a função nove
      break;

  }
  Serial.println(contador);//Imprime na serial o conteúdo de contador
  if (contador >= 10) {//Se contador for maior ou igual a 10
    contador = 0;//Atribui 0 a contador
  }
  if (contador <= -1) {//Se contador for menor ou igual a -1
    contador = 9;//Atribui 9 a contador
  }
}

SIMULAÇÃO NO TINKERCAD

SAIBA MAIS

Quer saber mais sobre o Kit Construindo o Jogo da Memória e + 20 Projetos,confira o vídeo:

Obrigado a todos e qualquer dúvida deixe nos comentários abaixo!

Abraços,

Carol Correia Viana