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
Bacharel em Engenharia Elétrica com ênfase em Eletrônica, mestra em Engenharia Industrial e especialista em Docência com ênfase em Educação Inclusiva. Atua no setor de Desenvolvimento de Produtos na Casa da Robótica. Editora chefe e articulista no Blog da Robótica. Fanática por livros, Star Wars e projetos Maker.
