Criando Jogos com Arduino: Passo a Passo
Jogo da Memória
Para melhor visualizar e/ou simular o circuito e a programação deste
projeto basta se acessar o seguinte link: http://blogdarobotica.com/tinkercad-
STOP .
JOGO DA MEMÓRIA
O jogo eletrônico Genius foi um brinquedo muito popular na década de
1980. Esse jogo busca estimular a memorização através de sequências de
cores e sons. Para vencer, o jogador deve reproduzir essas sequências na
mesma ordem em que lhe é apresentada.
A proposta desse projeto é criar um jogo de memória similar ao game
Genius utilizando componentes eletrônicos em conjunto com a placa UNO.
Neste projeto, reuniremos todos os conceitos básicos aprendidos até aqui para
nos divertir. Além disso, vamos aprender como produzir uma sequência de
números randômicos.
Para criar as sequências de cores e sons do jogo utilizaremos as funções
randomSeed ( ) e random ( ) .
MATERIAIS NECESÁRIOS
1 x Placa UNO SMD R3 Atmega328 compatível com Arduino UNO ;
1 x Cabo USB ;
1 x Protoboard ;
3 x LEDs difusos de 5 mm ;
1 x Display de 7 segmentos cátodo comum ;
9 x Resistores de 220 Ω ;
3 x Resistores de 10 kΩ ;
1 x Buzzer ativo ;
3 x Botões do tipo push button ;
ESQUEMÁTICO DE LIGAÇÃO DOS COMPONENTES
Conecte os componentes na protoboard como ilustra a Figura 24.
Verifique cuidadosamente os cabos de ligação antes de ligar sua placa UNO.
Lembre-se que a placa UNO deve estar desconectada enquanto você monta o
circuito.
Figura 24 - Circuito para Jogo da Memória.
Ao montar seu circuito na protoboard preste atenção nos seguintes
pontos:
Construiremos o Game Genius utilizando apenas três sequências de
cores e sons. Desta forma, utilizaremos três LEDs (vermelho, amarelo e
verde) e três botões que representaram as cores dos LEDs e que devem
ser pressionados pelo usuário para reproduzir a sequência;
O LED vermelho deve ser conectado à porta digital 13, o amarelo à
porta digital 12 e o verde à porta digital 11;
Utilizaremos o display de 7 segmentos para informar ao jogador em
qual nível do jogo ele está. 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 encontram-se conectado as portas digitais da seguinte
maneira: a = 4; b = 5; c = 6; d = 7; e = 8; f = 9; g = 10;
O buzzer ativo deve ser conectado à porta digital 3;
O primeiro botão, correspondente ao botão vermelho, será utilizado para
acionar o LED vermelho e deve ser conectado a uma resistência pull-
down e a porta analógica A5;
O segundo botão, correspondente ao botão amarelo, será utilizado para
acionar o LED amarelo e deve ser conectado a uma resistência pull-
down e a porta analógica A4;
O último botão, correspondente ao botão verde, será utilizado para
acionar o LED verde e deve ser conectado a uma resistência pull-down
e a porta analógica A3.
ELABORANDO O CÓDIGO
Com o circuito montado vamos a programação do Sketch do Jogo da
Memória. 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.
//ENTRADAS
int butRed = A5; //Atribui a porta A5 a variável butRed - botão vermelho
int butYel = A4; //Atribui a porta A4 a variável butYel - botão amarelo
int butGre = A3; //Atribui a porta A3 a variável butGre - botão verde
//SAÍDAS
//Led
int ledRed = 13; //Atribui a porta 13 a variável ledRed - LED vermelho
int ledYel = 12; //Atribui a porta 12 a variável ledYel - LED amarelo
int ledGre = 11; //Atribui a porta 11 a variável ledGre - LED verde
//Display
int a = 4; //Atribui a porta 4 a variável "a" - segmento a do display
int b = 5; //Atribui a porta 5 a variável "b" - segmento b do display
int c = 6; //Atribui a porta 6 a variável "c" - segmento c do display
int d = 7; //Atribui a porta 7 a variável "d" - segmento d do display
int e = 8; //Atribui a porta 8 a variável "e" - segmento e do display
int f = 9; //Atribui a porta 9 a variável "f" - segmento f do display
int g = 10; //Atribui a porta 10 a variável "g" - segmento g do display
//Buzzer
int buzzerPin = 3; //Atribui a porta 3 a variável buzzerPin - buzzer
//Tons botões
#define tomRed 294 //Tom para LED vermelho
#define tomYel 330 //Tom para LED amarelo
#define tomGre 350 //Tom para LED verde
//VARIÁVEIS
int rodada = 0; //Variável que armazenará o número de rodadas
int led = 0; //Variável que armazenará o valor randômico que representará o LED que estará
ligado
int temp_led_ligado = 600; //Tempo em que o LED deve estar ligado
int temp_led_desligado = 100; //Tempo em que o LED deve estar desligado
int mat[10]; //Vetor de 10 posições que armazenará a sequência
int posi_mat = 0; //Posição do vetor
void setup(){
//Configuração dos pinos de entrada
pinMode (butRed, INPUT );
pinMode (butYel, INPUT );
pinMode (butGre, INPUT );
//Configuração dos pinos de saída
pinMode (ledRed, OUTPUT );
pinMode (ledYel, OUTPUT );
pinMode (ledGre, OUTPUT );
pinMode (a, OUTPUT );
pinMode (b, OUTPUT );
pinMode (c, OUTPUT );
pinMode (d, OUTPUT );
pinMode (e, OUTPUT );
pinMode (f, OUTPUT );
pinMode (g, OUTPUT );
pinMode (buzzerPin, OUTPUT );
//Inicialização da comunicação serial
Serial . begin (9600);
//Função randômica
randomSeed ( analogRead (A0)); //Pega como referência um valor aleatório do canal analógico
para gerar os valores randômicos
inicio(); //Chama a função início
}
void loop (){
led = random (0, 3); //Gera o valor aleatório entre 0 e 2
mat[posi_mat] = led; //Guarda o valor gerado no vetor
switch (posi_mat) { //Liga o display conforme posição do vetor (nível do jogo)
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 ;
}
for ( int j = 0; j <= posi_mat; j++) { //Mostra a sequência dos LEDs sempre que passar o nível
switch (mat[j]) { //Liga o LED correspondente a valor que está no vetor na posição j
case 0:
digitalWrite (ledGre, HIGH ); //Liga LED verde analogWrite (buzzerPin, tomGre); //Emite tom para LED verde delay (200); //Intervalo de 200 milissegundos digitalWrite (buzzerPin, LOW ); //Desliga buzzer delay (temp_led_ligado);
digitalWrite (ledGre, LOW ); //Desliga LED verde delay (temp_led_desligado);
break ;
case 1:
digitalWrite (ledYel, HIGH ); //Liga LED amarelo analogWrite (buzzerPin, tomYel); //Emite tom para LED amarelo delay (200); //Intervalo de 200 milissegundos digitalWrite (buzzerPin, LOW ); //Desliga buzzer delay (temp_led_ligado);
digitalWrite (ledYel, LOW ); //Desliga LED amarelo delay (temp_led_desligado);
break ;
case 2:
digitalWrite (ledRed, HIGH ); //Liga LED vermelho
analogWrite (buzzerPin, tomRed); //Emite tom para LED vermelho delay (200); //Intervalo de 200 milissegundos digitalWrite (buzzerPin, LOW); //Desliga buzzer delay (temp_led_ligado);
digitalWrite (ledRed, LOW); //Desliga LED vermelho delay (temp_led_desligado) ;
break ;
default :
break ;
}
}
int temp = 0; //Variável temporária utilizada para aguardar o jogador digitar a sequência
fornecida pelo jogo
while (temp <= posi_mat){
if ( digitalRead (butGre) == HIGH ) { //Se butGre for nível alto - botão verde pressionado
digitalWrite (ledGre, HIGH ); //Liga LED verde analogWrite (buzzerPin, tomGre); //Emite tom para LED verde delay (100); //Intervalo de 100 milissegundos digitalWrite (buzzerPin, LOW ); //Desliga buzzer while ( digitalRead (butGre) == HIGH ); //Enquanto o botão verde estiver pressionado não
faz nada
digitalWrite (ledGre, LOW ); //Desliga o LED verde delay (200); //Intervalo de 200 milissegundos if ( mat[temp] == 0) { //Se na posição do vetor é verdadeiro (igual a zero)
temp = temp + 1; //Incrementa a variável temp para dar continuidade na sequência do jogo
} else //Se não
{
Serial . println ( "ERRO!!!!!" ); //Imprime na serial Erro
posi_mat = 11; //Atribui 11 na variável posi_mat
break ;
}
}
if ( digitalRead (butYel) == HIGH ) { //Se butYel for nível alto - botão amarelo pressionado
digitalWrite (ledYel, HIGH ); //Liga led amarelo analogWrite (buzzerPin, tomYel); //Emite tom para LED amarelo delay (100); //Intervalo de 100 milissegundos digitalWrite (buzzerPin, LOW ); //Desliga buzzer
while ( digitalRead (butYel) == HIGH ); //Enquanto o botão amarelo estiver pressionado não
faz nada
digitalWrite (ledYel, LOW );
delay (200);
if ( mat[temp] == 1) { //Se na posição do vetor é verdadeiro (igual a zero)
temp = temp + 1;
} else
{
Serial . println ( "ERRO!!!!!" );
posi_mat = 11; //Atribui 11 na variável posi_mat
break ;
}
}
if ( digitalRead (butRed) == HIGH ) { //Se butRed for nível alto - botão vermelho pressionado
digitalWrite (ledRed, HIGH ); //Liga led vermelho analogWrite (buzzerPin, tomRed); //Emite tom para led vermelho delay (100); //Intervalo de 100 milissegundos digitalWrite (buzzerPin, LOW ); //Desliga buzzer while ( digitalRead (butRed) == HIGH ); digitalWrite (ledRed, LOW );
delay (200);
if ( mat[temp] == 2) {
temp = temp + 1;
} else
{
Serial . println ( "ERRO!!!!!" ); //Imprime na serial "ERRO!!!!!"
posi_mat = 11; //Atribui 11 na variável posi_mat
break ;
}
}
}
posi_mat = posi_mat + 1;
if (posi_mat == 10) { //Se a posi_mat for igual a 10
ganhou(); //Chama a função ganhou()
Serial . println ( "Parabens voce venceu " ); //Imprime no serial "Parabens voce venceu"
posi_mat = 0; //Atribui 0 a variável posi_mat para reiniciar o jogo
Serial . println ( "INICIO DE JOGO" ); //Imprime no serial "INICIO DE JOGO"
}
if (posi_mat >= 11) { //Se posi_mat for maior ou igual a 11
Serial . println ( " ---- >>> FIM DE JOGO <<< ----" ); //Imprime no serial " ---- >>> FIM DE
JOGO <<< ----"
perdeu(); //Chama a função perdeu
posi_mat = 0; //Atribui 0 a variável posi_mat para reiniciar o jogo
Serial . println ( "INICIO DE JOGO" ); //Imprime no serial "INICIO DE JOGO" delay (3000); //Intervalo de 3 segundos
}
}
//Função para escrever os números no display
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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 inicio() {
for ( int y = 0; y < 2; y++) { //Repetir duas vezes
tone (buzzerPin, 330, 200); //Frequência e duração da nota Mi digitalWrite (ledRed, HIGH ); //Liga o LED vermelho delay (100); //Intervalo de 200 milissegundos tone (buzzerPin, 330, 200); //Frequência e duração da nota Mi digitalWrite (ledYel, HIGH ); //Liga o LED amarelo delay (100); //Intervalo de 200 milissegundos tone (buzzerPin, 330, 200); //Frequência e duração da nota Mi digitalWrite (ledGre, HIGH ); //Liga o LED verde delay (100); //Intervalo de 300 milissegundos tone (buzzerPin, 262, 300); //Frequência e duração da nota Dó delay (100); //Intervalo de 200 milissegundos digitalWrite (ledRed, LOW ); //Desliga o LED vermelho digitalWrite (ledYel, LOW ); //Desliga o LED amarelo digitalWrite (ledGre, LOW ); //Desliga o LED verde delay (500); //Intervalo de 0,5 segundos
}
}
void perdeu() {
for ( int x = 0; x < 3; x++) { //Repetir 3 vezes
for ( int z = 0; z < 3; z++) { //Repetir 2 vezes
tone (buzzerPin, 262, 200); //Frequência e duração da nota Dó digitalWrite (ledRed, HIGH ); //Liga LED vermelho digitalWrite (ledYel, HIGH ); //Liga LED amarelo digitalWrite (ledGre, HIGH ); //Liga LED verde delay (250); //Intervalo de 250 milissegundos digitalWrite (ledRed, LOW ); //Desliga o LED vermelho digitalWrite (ledYel, LOW ); //Desliga o LED amarelo digitalWrite (ledGre, LOW ); //Desliga o LED verde
}
tone (buzzerPin, 528, 300); //Frequência e duração da nota Dó delay (100); //Intervalo de 100 milissegundos
}
}
void ganhou() {
for (int w = 0; w < 2; w++) { //Repetir 2 vezes
tone (buzzerPin, 440, 200); //Frequência e duração da nota Lá digitalWrite (ledRed, HIGH ); //Liga led vermelho digitalWrite (ledYel, HIGH ); //Liga led amarelo digitalWrite (ledGre, HIGH ); //Liga led verde delay (250); //Intervalo de 250 milissegundos digitalWrite (ledRed, LOW ); //Desliga led vermelho digitalWrite (ledYel, LOW ); //Desliga led amarelo digitalWrite (ledGre, LOW ); //Desliga led verde tone (buzzerPin, 495, 200); //Frequência e duração da nota Si digitalWrite (ledRed, HIGH ); //Liga led vermelho digitalWrite (ledYel, HIGH ); //Liga led amarelo digitalWrite (ledGre, HIGH ); //Liga led verde delay (250); //Intervalo de 250 milissegundos digitalWrite (ledRed, LOW ); //Desliga led vermelho digitalWrite (ledYel, LOW ); //Desliga led amarelo digitalWrite (ledGre, LOW ); //Desliga led verde tone (buzzerPin, 528, 200); //Frequência e duração da nota Dó digitalWrite (ledRed, HIGH ); //Liga led vermelho digitalWrite (ledYel, HIGH ); //Liga led amarelo digitalWrite (ledGre, HIGH ); //Liga led verde delay (250); //Intervalo de 250 milissegundos digitalWrite (ledRed, LOW ); //Desliga led vermelho digitalWrite (ledYel, LOW ); //Desliga led amarelo digitalWrite (ledGre, LOW ); //Desliga led verde tone (buzzerPin, 528, 200); //Frequência e duração da nota Dó digitalWrite (ledRed, HIGH ); //Liga led vermelho digitalWrite (ledYel, HIGH ); //Liga led amarelo digitalWrite (ledGre, HIGH ); //Liga led verde delay (250); //Intervalo de 250 milissegundos digitalWrite (ledRed, LOW ); //Desliga led vermelho digitalWrite (ledYel, LOW ); //Desliga led amarelo digitalWrite (ledGre, LOW ); //Desliga led verde delay (500); //Intervalo de 500 milissegundos
}
}
Para melhor compreensão do código acompanhe os seguintes passos:
1- Declarar as variáveis
Assim como nos projetos anteriores, iniciamos a programação
declarando as variáveis. Utilizamos as variáveis butRe d , butYe l e butGr e
para representar os botões vermelho, amarelo e verde, e atribuímos a elas os
pinos analógicos A5, A4 e A3, respectivamente.
Em seguida, declaramos as variáveis ledRe d , ledYe l e ledGr e
atribuindo as portas digitais em que os LEDs se encontram conectados, ou
seja, as portas 13, 12 e 11, respectivamente.
Em seguida, declaramos uma variável para cada segmento do display.
Conforme o esquemático elétrico, atribuiremos a porta 4 a variável a ; a porta
5 a variável b ; a porta 6 a variável c ; a porta 7 a variável d ; a porta 8 a
variável e ; a porta 9 a variável f ; a porta 10 a variável g .
Logo após, atribuímos a porta 3, em que o buzzer está conectado, a
variável buzzerPi n . Para que o buzzer reproduza sons diferentes para cada
cor de LED declaramos as variáveis tomRe d , tomYe l , e tomGr e
atribuindo a elas o valor da frequência da nota musical desejada. Observe que
para declarar estas variáveis utilizamos a diretiva #defin e , que permite dar
um nome a um valor constante antes de o programa ser copilado. Nesse caso,
as constantes definidas no Arduino não ocupam espaço na memória de
programa do chip. Para saber mais sobre essa diretiva acesse:
https://www.arduino.cc/reference/pt/language/structure/further-syntax/define/
.
Declaramos também a variável rodad a para armazenar o número de
rodadas do jogo, le d para guardar o valor randômico que representará qual
LED deve ser acionado, temp_led_ligad o para armazenar o tempo em que o
LED deve permanecer ligado (600 milissegundos), e temp_led_desligad o para armazenar o tempo em que o LED deve permanecer desligado (100
milissegundos).
Além destas variáveis, declaramos também o vetor ma t com 10
posições para armazenar as sequências do jogo e a variável posi_ma t para
armazenar a posição do vetor.
2- Configurar os pinos de entrada e saída e inicializar a comunicação
serial
As variáveis butRe d , butYe l e butGr e foram configuradas como
entrada ( INPU T ). Por sua vez, as variáveis ledRe d , ledYe l , ledGr e , a
, b , c , d , e , f , g e buzzerPi n foram configuradas como saída ( OUTPU
T ).
A comunicação serial foi inicializada por meio da instrução: Serial .
begin (9600) ; .
3- Inicializar o gerador de números aleatórios e chamar função inicio()
O gerador de números aleatórios foi inicializado através da função
randomSeed ( analogRead (A0) ) que utiliza como entrada aleatória a leitura
analógica do pino A0.
Ainda no setup, chamamos a função inicio( ) que tocará uma melodia e
acionará os LEDs para representar o início do jogo.
4- Gerar um valor aleatório e armazenar no vetor
Através da instrução led = random (0, 3) ; geramos um valor aleatório
(0, 1 ou 2) e armazenamos na variável le d . O valor de led será armazenado
no vetor ma t na posição posi_ma t .
Por exemplo, ao iniciar o jogo posi_ma t será igual a 0 (zero), supondo
que o número aleatório gerado pela função rando m tenha sido 1, esse valor
será salvo na variável le d . Desta forma, o valor de le d (1) será armazenado
no vetor ma t na posição 0.
5- Verificar o valor de posi_mat
Toda vez que o jogador acertar a sequência de cores e sons a variável
posi_ma t será incrementada em 1. Utilizamos o valor armazenado nessa
variável como parâmetro da estrutura de controle de fluxo de seleção
switch...case , comparando esse valor aos números especificados nos cases.
Quando o valor armazenado em posi_ma t for igual ao caractere especificado
no case, a função para exibição do número correspondente no display deve ser
executada.
6- Criar estrutura que mostre a sequência dos LEDs sempre que passar o
nível
A cada nível acertado pelo jogador, o jogo deverá repetir a sequência
anterior e incluir mais um comando de LED aceso para ser memorizado. Por
exemplo, no nível 0 apenas o LED verde foi acionado, no nível 1 o LED
verde deve ser acionado novamente e mais um LED deverá ser acionado
(verde, amarelo ou vermelho, dependendo do valor aleatório gerado), e assim
sucessivamente.
Desta forma, criamos uma estrutura de repetição utilizando o for para
percorrer o vetor de forma que mostre toda a sequência gerada.
7- Criar estrutura que selecione os LEDs na sequência gerada
Para selecionar os LEDs na sequência gerada utilizamos a estrutura
switch... case , que verificará o valor armazenado no vetor ma t na posição j .
Caso o conteúdo de ma t na posição j seja igual a 0 o LED verde e seu tom
serão acionados, caso j seja igual a 1 o LED amarelo e seu tom serão
acionados, e sendo j igual a 2 o LED vermelho e seu tom serão acionados.
8- Declarar variável temporária para aguardar o jogador digitar a
sequência fornecida
Criamos a variável do tipo int para aguardar o jogador digitar a
sequência fornecida, através da instrução: int temp = 0;
9- Criar estrutura de controle para aguardar o usuário pressionar o botão
com a sequência No momento em que o usuário pressiona o botão será feita a comparação se a
sequência pressionada foi igual a gerada pelo jogo. Isso é feito através das
estruturas if de verificação que estão dentro do while .
A cada acerto da sequência a variável tem p é incrementada com o
objetivo de efetuar a próxima comparação, se houver. Caso o jogador
pressione a sequência incorreta será impresso uma mensagem de erro no
monitor serial, a variável posi_mat será igualada a 11 e um brea k será
executado para parar o laço de repetição while .
Para identificar se o jogador ganhou verificamos o valor da variável
posi_ma t . Se posi_ma t for igual a 10 indica a vitória do jogador e a função
ganhou( ) será chamada, tocando uma melodia.
Se o valor de posi_ma t for maior ou igual a 11 indica que o usuário
errou a sequência e a função perdeu( ) será chamada. Além disso, será
exibida na serial a mensagem: " ---- >>> FIM DE JOGO <<< ----" .
Em ambas as situações, o jogo será reiniciado atribuindo zero a variável
posi_ma t .
10- Criar as funções dos números a serem exibidos no display 7
segmentos
Em seguida, criamos as funções que serão responsáveis por acionar os
segmentos do display para que ele exiba números de 0 a 9. O display será
utilizado para mostrar ao jogador o nível em que ele está, sendo assim, a cada
sequência acertada o display incrementará em 1 o valor mostrado.
11- Criar as melodias nas funções inicio( ) , perdeu( ) e ganhou().
OBSERVAÇÃO:
Utilize o cabo para bateria 9 V com plug P4 para alimentar sua placa
UNO. Desse modo, você poderá jogar o Jogo da Memória sem a