Criando Jogos com Arduino 2: Passo a Passo
Piano Hero
O Piano Hero é inspirado no Guitar Hero, popular jogo de vídeo
game. No Guitar Hero, o jogador deve pressionar os botões do controle de
acordo com as notas coloridas que aparecem na tela. Substituiremos a tela
por LEDs, os botões do controle por botões push button e o vídeo game
pelo Arduino.
No Piano Hero, cada um dos sete botões representa uma nota
musical. Os LEDs azuis representam qual nota deverá ser tocada. O jogador
deve pressionar o botão da nota sinalizada pelo LED azul. Por exemplo, se
o LED azul ligado é o primeiro à esquerda, o jogador deverá tocar o
primeiro botão à esquerda (nota Dó). Os LEDs amarelos indicam a próxima
nota que será sinalizada pelos LEDs azuis.
Nesta versão, o Piano Hero com Arduino traz a música infantil Cai,
Cai, Balão.
MATERIAIS NECESSÁRIOS
1 x Placa UNO SMD compatível com Arduino UNO ;
1 x Cabo USB ;
2 x Protoboard ;
14 x LEDs difusos de 5 mm ;
14 x Resistores de 220 Ω ;
7 x Botões do tipo push button ;
7 x Resistores de 10 kΩ ;
1 x Buzzer passivo ;
Jumpers macho-macho ;
ESQUEMÁTICO DE LIGAÇÃO DOS COMPONENTES
Certifique-se que sua placa UNO esteja desligada e m onte
atentamente o circuito conforme a Figura 1 9 .
Ao montar seu circuito na protoboard, preste atenção nos seguintes
pontos:
O terminal mais curto do LED é o cátodo (negativo) e deve ser
conectado ao terra (GND). O terminal mais longo de cada LED
deve ser conectado ao pino correspondente. Observe que alguns
LEDs serão conectados aos pinos analógicos.
Em nosso projeto, utilizaremos resistores de 220 Ω para reduzir a
tensão e a corrente de alimentação dos LEDs;
O botão deve ser montado com dois terminais abaixo da cavidade
central da protoboard e os outros dois acima;
Para ler os botões usaremos uma única entrada analógica do
Arduino, utilizando como estratégia um divisor de tensão. Assim,
quando pressionado cada botão terá em sua saída níveis de tensão
diferentes.
O terminal positivo do buzzer deve ser conectado à porta digital 3
da placa UNO e o outro terminal deve ser ligado ao GND.
Figura 19 - Circuito para Projeto Piano Hero.
ELABORANDO O CÓDIGO
Antes de iniciar o código completo do projeto, vamos encontrar os
valores de referência de cada botão que representam as notas musicais.
O uso de apenas uma porta analógica do Arduino para realizar a
leitura de botões é bastante útil. Como a placa Uno possui apenas 14 portas
digitais, em projetos maiores, como o Piano Hero, podemos ficar sem pinos
digitais.
O pino analógico do nosso Arduino é conectado a um conversor
analógico-digital (ADC), com resolução de dez bits. Assim, o pino analógico retorna um valor numérico de 0 a 1023, que se refere a faixa de
tensão lida (entre 0 e 5 V).
O divisor de tensão utilizado no circuito dos botões permite que cada
botão retorne um nível de tensão diferente. Deste modo, para encontrar o
valor de referência dos botões, vamos apenas ler o valor analógico para
cada botão pressionado, conforme o código abaixo.
int botao = A0; //Correspondente a leitura dos botões
void setup ( ) {
Serial . begin (9600); //Inicia a cominicação Serial pinMode (botao, INPUT ); //Define botao como entrada
}
void loop () {
Serial . println ( analogRead (botao)); //Realiza a leitura
analógica do botão e imprime na serial
}
Após transferir este código para o seu Arduino, abra o monitor serial
e pressione os botões em sequência. Inicie pelo primeiro botão à esquerda,
ele representa a nota Dó, o segundo a nota Ré, e assim por diante.
Anote os valores mostrados no monitor serial com suas
correspondentes notas, pois vamos utilizá-los no código final do projeto
Piano Hero.
Em nosso teste, obtemos os seguintes resultados:
Nota Musical Valor analógico lido
Dó 145 Ré 169 Mi 203 Fá 254
Sol 340 Lá 508
Si 1020
Os seus resultados podem ser diferentes, por conta dos valores das
resistências.
De posse desses resultados, podemos elaborar o código para o
projeto Piano Hero. 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.
int ledAmarelo[] = {A1, A3, 4, 6, 8, 10, 12}; //LEDs da fileira
amarela(nota anterior)
int ledAzul[] = {A2, A4, 5, 7, 9, 11, 13}; //LEDs da fileira azul
(nota a ser tocada)
int botao = A0; //Correspondente a leitura dos botões
int buzzer = 3; //Correspondente ao buzzer
int leitura = 0; //Armazena a leitura do pino A0 conecta aos
botões
int quantidade_Notas = 30; //Quantidade de notas totais da música
cai, cai balão
//Matriz que guarda a sequência das notas da música cai, cai balão
String musica[] = { "SOL" ,
"SOL" ,
"FA" ,
"MI" ,
"SOL" ,
"SOL" ,
"FA" ,
"MI" ,
"SOL" ,
"LA" ,
"SOL" ,
"FA" ,
"MI" ,
"RE" ,
"RE" ,
"MI" ,
"FA" ,
"RE" ,
"MI" ,
"FA" ,
"RE" ,
"MI" ,
"FA" ,
"SOL" ,
"LA" ,
"SOL" ,
"FA" ,
"MI" ,
"RE" ,
"DO"
};
void setup () {
pinMode (botao, INPUT ); //Define botao como entrada pinMode (buzzer, OUTPUT ); //Define buzzer como saída
//Define os LEDs da fileira amarela e azul como saída
for ( int i = 0; i < 7; i++) {
pinMode (ledAmarelo[i], OUTPUT );
pinMode (ledAzul[i], OUTPUT );
}
//Desliga todos os LEDs da fileira amarela e azul
for ( int i = 0; i < 7; i++) {
digitalWrite (ledAmarelo[i], LOW );
digitalWrite (ledAzul[i], LOW );
}
}
void loop () {
//Laço de repetição para percorrer todas as notas do array de
notas
for ( int j = 0; j < quantidade_Notas; j++){ //Repete as
instruções enquanto j for menor que 30
// Liga LED azul e toca a nota correspondente...
if (musica[j]. equals ( "DO" )) { //Condição que verifica se a
nota da matriz é um Dó
digitalWrite (ledAzul[0], HIGH ); //Se sim, liga o LED azul
correspondente a nota Dó
do {
leitura = analogRead (botao); //Realiza a leitura do canal
analógico conectado aos botões
if (leitura == 145) { //Verifica se o valor lido foi igual ao
número correspondente do botão Dó
break ; //Se sim, para o laço de repetição
}
} while (1); //Enquanto não for pressionado o botão, o laço de
repetição continua
tone (buzzer, 262, 600); //Toca a nota Dó delay (400); //Intervalo necessário para tocar a nota Dó
}
if (musica[j]. equals ( "RE" )) {
digitalWrite (ledAzul[1], HIGH );
do {
leitura = analogRead (botao);
if (leitura == 169) {
break ;
}
} while (1);
tone (buzzer, 294, 300);
delay (300);
}
if (musica[j]. equals ( "MI" )) {
digitalWrite (ledAzul[2], HIGH );
do {
leitura = analogRead (botao);
if (leitura == 203) {
break ;
}
} while (1);
tone (buzzer, 330, 300);
delay (300);
}
if (musica[j]. equals ( "FA" )) {
digitalWrite (ledAzul[3], HIGH );
do {
leitura = analogRead (botao);
if (leitura == 254) {
break ;
}
} while (1);
tone (buzzer, 349, 300);
delay (300);
}
if (musica[j]. equals ( "SOL" )) {
digitalWrite (ledAzul[4], HIGH );
do {
leitura = analogRead (botao);
if (leitura == 340) {
break ;
}
} while (1);
tone (buzzer, 392, 300);
delay (300);
}
if (musica[j]. equals ( "LA" )) {
digitalWrite (ledAzul[5], HIGH );
do {
leitura = analogRead (botao);
if (leitura == 508) {
break ;
}
} while (1);
tone (buzzer, 440, 300);
delay (300);
}
if (musica[j]. equals ( "SI" )) {
digitalWrite (ledAzul[6], HIGH );
do {
leitura = analogRead (botao);
if (leitura == 1020) {
break ;
}
} while (1);
tone (buzzer, 493, 300);
delay (300);
}
// Liga LED Amarelo...
if ( j < quantidade_Notas - 1) { //Condição responsável por
acionar o LED amarelo até a penúltima nota
if (musica[j + 1]. equals ( "DO" )) { //Condição que verifica
se a próxima nota da matriz é um Dó
digitalWrite (ledAmarelo[0], HIGH ); //Se sim, liga o LED
amarelo correspondente a nota Dó
}
if (musica[j + 1]. equals ( "RE" )) {
digitalWrite (ledAmarelo[1], HIGH );
}
if (musica[j + 1]. equals ( "MI" )) {
digitalWrite (ledAmarelo[2], HIGH );
}
if (musica[j + 1]. equals ( "FA" )) {
digitalWrite (ledAmarelo[3], HIGH );
}
if (musica[j + 1]. equals ( "SOL" )) {
digitalWrite (ledAmarelo[4], HIGH );
}
if (musica[j + 1]. equals ( "LA" )) {
digitalWrite (ledAmarelo[5], HIGH );
}
if (musica[j + 1]. equals ( "SI" )) {
digitalWrite (ledAmarelo[6], HIGH );
}
}
//Desliga todos os LEDs da fileira amarela e azul
for ( int i = 0; i < 7; i++) {
digitalWrite (ledAmarelo[i], LOW );
digitalWrite (ledAzul[i], LOW );
}
}
}
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. Os LEDs da fileira amarela (portas A1, A3, 4, 6, 8, 10 e 12)
foram declarados no array ledAmarelo[ ] e os da fileira azul (portas A2,
A4, 5, 7, 11 e 13) foram declarados no array ledAzul[ ] .
Em seguida, declaramos as variáveis bota o e buzzer ,
correspondentes aos pinos A0 e digital 3, em que os botões e o buzzer estão
conectados, respectivamente.
Declaramos também a variável leitur a para armazenar a leitura do
pino A0 e a variável quantidade_Nota s para guardar a quantidade de notas
totais da música caí, caí balão.
No array musica[ ] escrevemos todas as notas em sequência para
tocar a música caí, caí balão.
2. Configurações iniciais do projeto
Na função setup ( ) , realizamos as configurações iniciais do nosso
projeto. Inicialmente, definimos as portas de entrada e saída. A variável
bota o foi definida como entrada e a variável buzze r foi configurada como
saída.
As portas correspondentes aos LEDs azuis e amarelos também foram
declaradas como saída. Fizemos isso percorrendo os elementos do array e
os configurando como saída ( OUTPU T ), com o auxílio da estrutura de
repetição fo r .
Ainda na função setup ( ) , vamos também desligar todos os LEDs.
Fizemos isso percorrendo os elementos do array e os configurando como
desligado ( LO W ), com o auxílio da estrutura de repetição fo r .
3. Percorrer todas as notas música caí, caí balão guardadas no array
Para que os LEDs azuis indiquem qual a nota deve ser tocada e os
LEDs amarelos sinalizem a próxima nota a ser tocada, vamos percorrer
todas as posições do array musica[ ] . Para isso, usamos a estrutura de
repetição fo r , em que definimos a variável inteira j = 0 na inicialização,
testamos se j é um número menor que 30 (armazenado na variável
quantidade_Nota s ) na condição, e somamos j+ + no incremento.
4. Verificar nota a ser tocada, acionar o LED azul correspondente a nota a
ser tocada e realizar a leitura do botão
Para verificar a nota a ser tocada, acionar o LED azul correspondente
e ler o botão usamos 7 estruturas de seleção i f , uma para cada nota
musical.
Por meio da instrução if (musica[j]. equals ( "DO" ) ) , verificamos
se a string da matriz musica[ ] na posiçã o j é igual a nota musical Dó. A
função equals ( ) verifica se duas strings são iguais.
Se a condição for verdadeira (string de musica[ ] igual a Dó), o LED
azul correspondente a nota Dó será acionado, ou seja, o primeiro LED à
esquerda e o programa entra na estrutura de repetição d o .. . whil e .
Dentro da estrutura d o .. . whil e , realizamos a leitura do botão e
comparamos se o valor lido é igual ao valor analógico lido do botão
correspondente à nota Dó ( if (leitura == 145 ) ).
OBSERVAÇÃO : Substitua 145 pelo valor analógico obtido ao pressionar
o botão correspondente a nota Dó, que encontramos no código de teste dos
botões (valor de referência).
Quando o jogador pressiona o botão correspondente a nota Dó, o
programa sai do laço de repetição e o buzzer toca a nota Dó. No entanto, se
ele pressionar o botão errado nenhum som será emitido.
Repetimos as mesmas instruções para as outras notas musicais.
5. Verificar próxima nota a ser tocada e acionar o LED amarelo
correspondente a nota
De mesmo modo, para verificar a próxima nota a ser tocada e
acionar o LED amarelo correspondente, usamos 7 estruturas de seleção i f ,
uma para cada nota musical.
Através da instrução if (musica[j+1]. equals ( "DO" ) ) , verificamos
se a string da matriz musica[ ] na posiçã o j+ 1 é igual a nota musical Dó.
Em outras palavras, verificamos se a próxima posição do array musica[ ] é
igual a Dó.
Se a condição for verdadeira (string de musica[ ] igual a Dó), o LED
amarelo correspondente a nota Dó será acionado, ou seja, o primeiro LED à
esquerda.
Repetimos as mesmas instruções para as outras notas musicais.
6. Desligar todos os LEDs para reiniciar o jogo
Quando a variável j assumir um valor maior que a variável
quantidade_Nota s , o programa saí do primeiro laço de repetição fo r ,
indicando que todas as notas da música caí, caí balão foram tocadas.
Para finalizar o código desligamos todos os LEDs azuis e amarelos.
Fizemos isso percorrendo os elementos dos arrays e os configurando como
desligado ( LO W ), com o auxílio da estrutura de repetição fo r .
TINKERCAD
Para melhor visualizar e/ou simular o circuito e as programações
deste projeto, basta acessar os seguintes links:
Teste dos botões: www.blogdarobotica.com/tinkercad-botao-pianohero
Piano Hero completo: www.blogdarobotica.com/tinkercad-pianohero
OceanofPDF.com