Buzz Wire com Contador

 

No jogo Buzz Wire, o jogador precisa guiar uma haste de metal ao

longo de um circuito de arame curvado sem tocá-lo. Para ganhar, o jogador

precisa ter a mão firme para completar o circuito.

Neste projeto, construiremos o jogo Buzz Wire usando Arduino,

LEDs, display de 7 segmentos, um botão e um buzzer.

Se o jogador deixar a haste tocar no circuito de arame o buzzer

emitirá um beep e o LED vermelho será acionado. O display de 7

segmentos será usado para contar quantas vezes o jogador tocou o circuito

de arame.

Você tem a mão firme o suficiente para completar o circuito sem

bater no fio e disparar o buzzer? Chame seus amigos e familiares para

competir!

 

MATERIAIS NECESSÁRIOS

1 x Placa UNO SMD compatível com Arduino UNO ;

1 x Cabo USB ;

2 x Protoboard ;

1 x Display de 7 segmentos ânodo comum ;

2 x LEDs difusos de 5 mm ;

9 x Resistores de 220 Ω ;

1 x Botões do tipo push button ;

2 x Resistores de 10 kΩ ;

1 x Buzzer passivo ;

Jumpers macho-macho ;

Arame de metal ou fio desencapado de 0,8 mm.

 

CONSTRUÇÃO DA HASTE E DO CIRCUITO DE ARAME

 

Construa a haste ( Figura 1 6 ) com o arame de metal ou o fio

desencapado , deixando um gancho circular na ponta.

Para o circuito ( Figura 1 7 ), molde o arame de metal ou o fio

desencapado de acordo com sua preferência. Você pode fazer várias ondas e

loops.

O nível de dificuldade do jogo é decidido na construção da haste e

do circuito. Quanto menor for o gancho na ponta da haste ou quanto mais

ondulado for o circuito, mais difícil será atravessar o circuito sem tocá-lo e

disparar o buzzer.

 

Figura 16 – Haste de Arame.

Figura 17 - Circuito de Arame.

 

ESQUEMÁTICO DE LIGAÇÃO DOS COMPONENTES

 

Inicialmente, certifique-se que sua placa UNO esteja desligada. M

onte atentamente o circuito conforme a Figura 1 8 .

Figura 18 - Circuito para Projeto Buzz Wire.

 

Ao montar seu circuito na protoboard, preste atenção nos seguintes

pontos:

O display de 7 segmentos é formado por sete LEDs retangulares

dispostos de forma que, por meio da combinação de LEDs ligados e

desligados, possa ser mostrada informações alfanuméricas

(números e letras);

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;

O display de 7 segmentos que estamos usando é do tipo ânodo

comum, então um dos terminais comuns do mesmo deve ser

conectado ao 5 V;

Vamos conectar um resistor de 220 Ω em cada um dos segmentos

do display;

Os segmentos encontram-se conectados as portas digitais do

Arduino na seguinte ordem: a = 13; b = 12; c = 11; d = 10; e = 9; f

= 8; g = 7;

Dois LEDs serão usados para sinalização. O LED conectado à porta

digital 6 será ligado quando a haste tocar o arame do circuito. O

LED conectado à porta 5 ficará ligado quando a haste não estiver

tocando o arame;

Em nosso projeto, utilizaremos resistores de 220 Ω para reduzir a

tensão e a corrente de alimentação dos LEDs;

Um push button será usado para reiniciar o jogo, voltando o

contador do display para zero;

Conecte o push button com um resistor de 10 kΩ pull-down

(resistor conectado no GND). Desta forma, quando o botão estiver

pressionado a placa UNO retornará nível lógico alto (HIGH).

O pino digital 4 será responsável pela leitura do botão;

O terminal positivo do buzzer deve ser conectado à porta digital 3

da placa UNO e o outro terminal deve ser ligado ao GND;

A porta digital 2 da placa UNO deve ser conectada a haste de metal

e a um resistor de 10 k Ω pull-down (resistor conectado no GND).

Desta forma, quando a haste não estiver tocando o arame do

circuito o pino digital 2 do Arduino, receberá nível lógico baixo

(LOW);

Em outra protoboard encaixe o circuito de arame e conecte-o a

alimentação de 5V (VCC);

Quando a haste de metal tocar o circuito de arame o pino digital 2

receberá nível alto (HIGH).

 

ELABORANDO O CÓDIGO

 

Com a haste e circuito de arame construídos e circuito montado,

vamos a programação do jogo. Para melhor compreensão, o código será

explicado passo a passo a seguir. Neste momento, observe o código abaixo

e aproveite para analisar sua estrutura.

 

//Pinos conectados aos LEDs do display

#define a 13 //Correspondente ao LED a

#define b 12 //Correspondente ao LED b

#define c 11 //Correspondente ao LED c

#define d 10 //Correspondente ao LED d

#define e 9 //Correspondente ao LED e

#define f 8 //Correspondente ao LED f

#define g 7 //Correspondente ao LED g

 

//Pinos conectados aos LEDs

#define ledVermelho 6 //Correspondente ao LED vermelho

#define ledVerde 5 //Correspondente LED verde

 

#define botao 4 //Correspondente ao botão

#define buzzer 3 // Correspondente ao buzzer

#define haste 2 //Correspondente a haste de metal

 

int botaoLeitura = 0; //Armazena a leitura do pino conectado ao botão

 

int leitura = 0; //Armazena a leitura do pino conectado a haste

int ultleitura = 0; //Armazena a última leitura do pino conectado a haste

int contador = 0; //Correspondente ao contador

 

void setup () {

 

Serial . begin (9600); //Inicia a comunicação serial

 

//Configura os pinos conectados aos LEDs do display, os LEDS e o buzzer como saída

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 (ledVerde, OUTPUT ); //Define ledVerde como saída pinMode (ledVermelho, OUTPUT ); //Define ledVermelho como saída pinMode (buzzer, OUTPUT ); //Define buzzer como saída

 

//Configura os pinos conectados ao botão e a haste como entrada

pinMode (botao, INPUT ); //Define botao como entrada pinMode (haste, INPUT ); //Define haste como entrada

}

 

void loop () {

digitalWrite (ledVerde, HIGH ); //Liga o LED verde digitalWrite (ledVermelho, LOW ); //Desliga o LED vermelho

 

botaoLeitura = digitalRead (botao); //Guarda a leitura do botao na variável botaoLeitura if (botaoLeitura == HIGH ) { //Se o botão for apertado

contador = 0; //Zera o contador

}

 

leitura = digitalRead (haste); // Lê o estado de buttonPin e armazena em leitura Serial . println (leitura); //Imprime na serial o conteúdo de leitura

if (leitura != ultleitura) { // Compara a leitura de haste com a leitura anterior

if (leitura == HIGH ) { //Se leitura for igual a HIGH

digitalWrite (ledVerde, LOW ); //Desliga o LED verde digitalWrite (ledVermelho, HIGH ); //Liga o LED vermelho tone (buzzer, 1500); //Liga o buzzer com uma frequência de 1500 Hz. delay (500); //Intervalo de 500 milissegundos noTone (buzzer); //Desliga o buzzer.

contador++; //Incrementa contador em 1

}

}

ultleitura = leitura; //Atribui a ultleitura o conteúdo de leitura

 

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 ;

}

 

if (contador >= 10) { //Se contador for maior ou igual a 10

contador = 0; //Retorna contador a zero

}

}

//Funções para escrever os números no display de 7 segmentos

//Função para escrever o nº zero

void zero() {

digitalWrite (a, 0); //coloca a em nível baixo digitalWrite (b, 0); //coloca b em nível baixo digitalWrite (c, 0); //coloca c em nível baixo digitalWrite (d, 0); //coloca d em nível baixo digitalWrite (e, 0); //coloca e em nível baixo digitalWrite (f, 0); //coloca f em nível baixo digitalWrite (g, 1); //coloca g em nível alto delay (100);

}

//Função para escrever o nº um

void um() {

digitalWrite (a, 1);

digitalWrite (b, 0);

digitalWrite (c, 0);

digitalWrite (d, 1);

digitalWrite (e, 1);

digitalWrite (f, 1);

digitalWrite (g, 1);

delay (100);

}

//Função para escrever o nº dois

void dois() {

digitalWrite (a, 0);

digitalWrite (b, 0);

digitalWrite (c, 1);

digitalWrite (d, 0);

digitalWrite (e, 0);

digitalWrite (f, 1);

digitalWrite (g, 0);

delay (100);

}

//Função para escrever o nº três

void tres() {

digitalWrite (a, 0);

digitalWrite (b, 0);

digitalWrite (c, 0);

digitalWrite (d, 0);

digitalWrite (e, 1);

digitalWrite (f, 1);

digitalWrite (g, 0);

delay (100);

}

//Função para escrever o nº quatro

void quatro() {

digitalWrite (a, 1);

digitalWrite (b, 0);

digitalWrite (c, 0);

digitalWrite (d, 1);

digitalWrite (e, 1);

digitalWrite (f, 0);

digitalWrite (g, 0);

delay (100);

}

//Função para escrever o nº cinco

void cinco() {

digitalWrite (a, 0);

digitalWrite (b, 1);

digitalWrite (c, 0);

digitalWrite (d, 0);

digitalWrite (e, 1);

digitalWrite (f, 0);

digitalWrite (g, 0);

delay (100);

}

//Função para escrever o nº seis

void seis() {

digitalWrite (a, 0);

digitalWrite (b, 1);

digitalWrite (c, 0);

digitalWrite (d, 0);

digitalWrite (e, 0);

digitalWrite (f, 0);

digitalWrite (g, 0);

delay (100);

}

//Função para escrever o nº sete

void sete() {

digitalWrite (a, 0);

digitalWrite (b, 0);

digitalWrite (c, 0);

digitalWrite (d, 1);

digitalWrite (e, 1);

digitalWrite (f, 1);

digitalWrite (g, 1);

delay (100);

}

//Função para escrever o nº oito

void oito() {

digitalWrite (a, 0);

digitalWrite (b, 0);

digitalWrite (c, 0);

digitalWrite (d, 0);

digitalWrite (e, 0);

digitalWrite (f, 0);

digitalWrite (g, 0);

delay (100);

}

//Função para escrever o nº nove

void nove() {

digitalWrite (a, 0);

digitalWrite (b, 0);

digitalWrite (c, 0);

digitalWrite (d, 0);

digitalWrite (e, 1);

digitalWrite (f, 0);

digitalWrite (g, 0);

delay (100);

}

 

Para melhor compreensão do código acompanhe os seguintes passos:

1. Declarar as variáveis

Iniciamos a programação declarando as variáveis correspondentes

aos LEDs do display de 7 segmentos. 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, declaramos 2 variáveis para os LEDs ( ledVermelho e

ledVerd e ), uma variável para o botão ( bota o ), uma variável para o

buzzer ( buzze r ) e outra para a haste de metal ( hast e ).

Além destas, declaramos também uma variável para armazenar a

leitura do botão ( botaoLeitur a ), uma para armazenar a leitura do pino

conectado a haste ( leitur a ), uma para guardar a última leitura do pino

conectado a haste ( ultleitur a ) e uma correspondente ao contador (

contado r ).

 

2. Inicialização da comunicação serial e configuração das portas de

entrada e saída

A comunicação serial foi inicializada por meio da instrução: Serial .

begin (9600) ; .

Configuramos como saída ( OUTPU T ) as variáveis

correspondentes aos LEDs do display de 7 segmentos, LEDS e buzzer.

As variáveis bota o e hast e foram definidas como entradas ( INPU

T ).

 

3. Definir LED verde como ligado e LED vermelho como desligado

No jogo, os LEDs serão usados como sinalização. O LED verde

ficará ligado se a haste não estiver tocando o arame. O LED vermelho será

ligado quando a haste tocar o arame do circuito.

Desse modo, iniciamos a função loop ( ) colocando a variável

ledVerde em nível alto ( HIG H ), ligando o LED verde, e a variável

ledVermelho em nível baixo ( LO W ), desligando o LED vermelho.

 

4. Realizar a leitura do botão e verificar se ele foi pressionado

Em seguida, realizamos a leitura do botão, variável bota o , e

atribuímos o resultado da leitura a variável botaoLeitur a . Isso foi feito

através da instrução botaoLeitura= digitalRead (botao) ; .

Em seguida, verificamos se o botão foi pressionado ( if (

botaoLeitura == HIGH ) ). Sendo a condição satisfeita, a variável contado

r será zerada ( contador = 0 ; ), reiniciando o jogo.

 

5. Realizar a leitura do pino conectado a haste e imprimir no monitor

serial

De mesmo modo, vamos realizar a leitura do pino conectado a haste,

variável hast e , e atribuir o resultado da leitura a variável leitur a .

Incluímos a instrução Serial . println (leitura) ; para que seja exibido

seu valor no monitor serial. Com isso, podemos testar de fato se o Arduino

recebe nível lógico baixo (zero) quando a haste não está tocando o circuito

de arame e se esse valor muda para 1 quando ela toca o circuito.

 

6. Comparar o valor de leitura com o valor de ultleitura

Precisamos saber quantas vezes a haste tocou no circuito de arame e

quantas mudanças de estado isto ocasionou. Para fazer essa detecção,

precisamos comparar o estado de leitura do pino conectado a haste com a

sua leitura anterior. Fizemos isso através das seguintes instruções:

 

if (leitura != ultleitura) { // Compara a leitura de haste com a

leitura anterior

if (leitura == HIGH ) { //Se leitura for igual a HIGH

digitalWrite (ledVerde, LOW ); //Desliga o LED verde digitalWrite (ledVermelho, HIGH ); //Liga o LED vermelho tone (buzzer, 1500); //Liga o buzzer com uma frequência de

1500 Hz.

delay (500); //Intervalo de 500 milissegundos noTone (buzzer); //Desliga o buzzer.

contador++; //Incrementa contador em 1

}

}

 

7. Verificar o valor de contado r

Utilizaremos a estrutura de controle de fluxo de seleção switch ... cas

e para comparar o valor armazenado na variável contado r aos números

especificados nos comandos cases. Quando o valor armazenado for igual ao

caractere especificado no case, a função para exibição do número

correspondente deve ser executada.

8. Comparar se o valor de contador é maior ou igual a 10

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 contado r . Sempre que contado r assumir um valor maior ou igual a 10,

seu valor será zerado.

 

9. Criar as funções para escrever os números no display

Para que os números sejam exibidos no display de 7 segmentos,

criamos uma função para cada número. Cada função contém a combinação

de segmentos que devem ser acionados (colocados em nível baixo) para

exibir o número desejado. Na Tabela estão listados os segmentos que devem

ser acionados para formação dos números de 0 a 9.

 

Tabela 7 - Número e sequência de segmentos.

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

Por exemplo, a função zero( ) contém todas as instruções para

acionamento dos segmentos do display exibindo o número zero. Conforme

a tabela, precisamos colocar em nível baixo as variáveis a , b , c , d , e ,

e f e colocar em nível alto a variável g . A função zero( ) foi escrita da

seguinte forma:

//Função para escrever o nº zero

void zero() {

digitalWrite (a, 0); //coloca a em nível baixo digitalWrite (b, 0); //coloca b em nível baixo digitalWrite (c, 0); //coloca c em nível baixo digitalWrite (d, 0); //coloca d em nível baixo digitalWrite (e, 0); //coloca e em nível baixo digitalWrite (f, 0); //coloca f em nível baixo digitalWrite (g, 1); //coloca g em nível alto delay (100);

}

 

TINKERCAD

 

Para melhor visualizar e/ou simular o circuito e a programação

deste projeto, acesse o seguinte link: www.blogdarobotica.com/tinkercad-

buzzwire .

Observação : No Tinkercad o botão foi inserido apenas para que a

simulação do código pudesse acontecer. Neste caso, o botão pressionado

simula o toque da haste no circuito de arame.

 

OceanofPDF.com