O Arduino é bem versátil e pode ser utilizado para diversas aplicações. Uma bem interessante é a criação de jogos ou mini-games com a plaquinha. Portanto, neste post, vamos criar um jogo utilizando o Arduino e alguns componentes simples. Assista o vídeo abaixo para ver o mini-game finalizado.

Ideia e informações importantes

Primeiro, precisamos definir como será o mini-game e quais componentes iremos utilizar. Minha ideia é fazer um jogo de ritmo, estilo o Guitar Hero (um dos mais famosos desse estilo). E pretendo criar algo simples, que não exija componentes difíceis de encontrar ou um código de mil linhas.

Parte visual

Sendo assim, para a parte visual que dita o ritmo, vou utilizar LEDs. Poderia utilizar um display ou a matriz de LED, mas ambos complicariam o projeto. O interessante de utilizar um display é que eu poderia mostrar o placar do jogo e as frases de interação muito facilmente. A ideia é que tenham 3 fileiras de LEDs com 3 LEDs em cada. E cada fileira representa um ‘ritmo’ que o jogador deve acompanhar. Portanto, os LEDs de cada fileira vão acendendo do começo ao fim indicando o ritmo que a pessoa deve seguir, conforme imagem abaixo:

esquema de LEDs do mini-game

Dessa forma, quando a fileira chegar na posição 3, a pessoa deve acertar o ritmo. Se ela fizer isso, ela ganha ponto.

Controle

Para controlar o mini-game, vou utilizar um potenciômetro linear. Isso, porque ele é simples de ser encontrado, é fácil de utilizar e cria uma interação com o jogo que pode ser divertida e desafiadora. Eu poderia utilizar também um acelerômetro ou botões para fazer a interação entre a pessoa e o jogo. Como serão três fileiras, dividirei o potenciômetro em três partes e cada uma será correspondente ao acionamento de cada fileira. Por exemplo: se a fileira 1 chegar na posição 3, a pessoa deve mover o potenciômetro para a esquerda.

Sinalização sonora

Por fim, é interessante ter um elemento sonoro para indicar ao jogador que ele errou ou acertou a sequência ou até que o jogo encerrou. A forma mais fácil é utilizar um buzzer ou então um alto-falante.

 

Com tudo isto em mente, podemos dar início ao nosso projeto.

Circuito

Montagem

Como o objetivo é utilizar 9 LEDs, montar isso em uma protoboard comum pode ser complicado por causa do espaço. Para contornar isso e deixar os componentes bem espaçados, vou usar uma protoboard grande. Fiz uma organização previa dos componentes para ver como tudo vai ficar em questão de espaço. Veja a imagem abaixo:

mini-game montagem parte 1

Coloquei os LEDs de forma que eles ficassem bem separados para ter uma sensação visual mais agradável possível e não dificultar a ligação. Eles já estão organizados em fileiras na imagem. Eu utilizei as mesmas cores da imagem que mostrei no tópico anterior (difícil saber por essa imagem já que é tudo transparente).

O potenciômetro eu posicionei de forma a facilitar o entendimento da dinâmica do mini-game. Minha ideia é que: se ele estiver para a esquerda ele aciona o ‘ritmo’ da fileira 1; se estiver no meio aciona a fileira 2; e se estiver para a direita ele aciona a fileira 3. Ou seja, essa lógica está de acordo com seu posicionamento na plaquinha.

Por fim, a posição do buzzer não importa muito. Desde que ele não esteja tampado e dê pra ouví-lo tranquilamente, está tudo certo. Agora é só planejar o circuito e fazer a ligação.

Ligação

circuito do mini-game

A imagem pode assustar a princípio. Porém, garanto que o circuito é bem simples e está de acordo com o que vimos em outros posts do site. Vamos por partes para facilitar o entendimento:

  • LEDs
    • Basta interligar o cátodo (negativo) de todos e ligar no GND do Arduino
    • O ânodo de cada um deve ser ligado a um resistor (pode ser de outro valor acima de 220Ω)
    • A outra ponta do resistor é ligada em um pino digital do Arduino da seguinte forma: os LEDs da primeira fileira são ligados nos pinos 3, 4 e 5. Sendo que o LED da 1ª ordem de acendimento é ligado no pino 3, o da 2ª ordem no pino 4 e o da 3ª ordem no pino 5. A mesma lógica se repete para os LEDs da fileira 2 e 3, com os da 2ª fileira ligados nos pinos 6,7 e 8. E os da 3ª fileira ligados nos pinos 9, 10 e 11
    • Essa ordem descrita acima facilitará bastante na hora de programar
  • Buzzer
    • O positivo do buzzer deve ser ligado no pino digital 2. No meu modelo existe um + indicando o positivo. Se no seu não houver, ligue em qualquer ponta do buzzer.
    • A outra ponta do buzzer deve ser ligada no GND do Arduino
  • Potenciômetro
    • As extremidades devem ser ligadas, uma no GND e outra no 5v do Arduino
    • O pino central deve ser ligado no pino analógico A0 do Arduino
    • O valor do potenciômetro pode ser qualquer um. A lógica que utilizaremos apenas pegara os intervalos de tensão em cima do pino central.

Veja a imagem abaixo da protoboard depois da montagem:

mini-game montagem 2

Explicação da programação

A maneira que fiz o código é consequência do raciocínio que desenvolvi, mas com certeza você pode pensar em outra forma de criar as lógicas do código.

Para simplificar o entendimento do programa e facilitar o desenvolvimento, vou dividir o programa em várias funções diferentes. E vou explicar as partes fundamentais. O restante você deve ser capaz de entender lendo os comentários que deixei ao longo do código.

Obs.: Muitas das variáveis que vou comentar foram criadas no início do código, pois são utilizadas em quase toda parte da programação.

Configurações dos pinos

A primeira coisa a ser feita é declarar os pinos correspondentes aos LEDs, buzzer e potenciômetro.

1
2
3
4
5
6
7
8
//Declara as variaveis para controlar os LEDs
int ledsLaranja[3] = {3,4,5}; //LEDs da fileira 1
int ledsVerde[3] = {6,7,8}; //LEDs da fileira 2
int ledsAzul[3] = {9,10,11}; //LEDs da fileira 3

//Define os pinos para o buzzer e o potenciômetro
#define buzzer 2
#define controle A0

Criei um vetor para designar os pinos, pois isso facilitará a lógica de acionamento deles. Depois disso, resta definir eles como saída ou entrada no setup. Na parte de definir os LEDs como saída, eu aproveitei para deixar todos desligados (estado inicial do mini-game).

1
2
3
4
5
6
7
8
9
10
11
12
13
void setup() {
  int i;
  for(i=0; i < 3;i++){ //Define os LEDs como saida
    pinMode(ledsLaranja[i], OUTPUT);
    pinMode(ledsVerde[i], OUTPUT);
    pinMode(ledsAzul[i], OUTPUT);
    digitalWrite(ledsLaranja[i], LOW);
    digitalWrite(ledsVerde[i], LOW);
    digitalWrite(ledsAzul[i], LOW);
  }

  pinMode(buzzer, OUTPUT);
  pinMode(controle, INPUT);

Mensagens de aviso

Decidi utilizar o monitor serial para o jogador saber a hora que o jogo começou e o seu placa no fim do jogo. Por isso os pinos 0 e 1 não foram utilizados.

Em relação a programação, essa parte é bem simples. Bastou inciar a comunicação serial no setup (Serial.begin(9600)) e mandar escrever os comandos ao longo do código.

Acionamento dos LEDs

Criarei uma função chamada void acionarFileiras().

Para fazer o acionamento dos LEDs, vou seguir a lógica da imagem no início do post: o 1º LED da fileira se acende; depois de um tempo ele se apaga e o do meio acende; depois o do meio apaga e o ultimo LED acende; depois o último LED se apaga.

Problema de interferência

Aqui temos um grande problema: enquanto a sequência de acionamento ocorre, o restante do programa deve rodar sem interrupção. Portanto, vou utilizar uma técnica para rodar duas coisas ao mesmo tempo (veja o post). Os procedimentos que descreverei a seguir se aplicam às 3 fileiras, mas mostrarei só o caso da fileira 1.

O primeiro passo é criar uma variável de tempo para criar o delay que não atrapalha nas demais funções. Dei o nome de tempoFileira1 à variável. Além disso, é interessante que o tempo da sequência dos LEDs seja ajustável para que uma hora seja mais rápido e outra seja mais lento. Sendo assim, criei outra variável chamada delayFileira1. Com essas variáveis, criei o seguinte condicional:

if(abs(millis()-tempoFileira1) > delayFileira1){

Isso garante que o que for rodar dentro do if não atrapalhe o restante do código.

Acender e apagar

Para o código saber em qual ordem de acionamento a fileira está, criei uma variável chamada fileira1. Essa variável pode ter 5 estados:

  • Se for igual à:
    • 0: inicio da sequência. Quer dizer que o programa está mandando aquela sequência ser iniciada
    • 1: passo 1 da sequência
    • 2: passo 2 da sequência
    • 3: passo 3 da sequência (apaga o último LED e da barulho de erro
    • 4: sequência parada ou inativa

Essa parte do código não tem muito mistério. A cada passo, os LEDs são acionados e apagados e a variável fileira1 é incrementada 1 passo, para que no próximo delay o próximo passo seja executado. O único passo diferente é o 3, que possui o barulho de erro. Para isso, utilizei a função tone() do Arduino para acionar o buzzer:

1
2
3
4
5
}else if(fileira1 == 3){
    digitalWrite(ledsLaranja[2], LOW);
    tone(buzzer, 370, 200); //Som para indicar que a pessoa 'perdeu' o LED
    fileira1 ++;
}

370 é a frequência para o Fa# e 200 é a duração do som (em ms). Usei essa frequência por motivos aleatórios mesmo.

O último detalhe importante dessa função é garantir o delay, igualando a variável tempoFileira1 ao millis() em todo passo que não seja o 3:

if (fileira1 < 3){ //Garante que o ultimo acionamento nao atrapalhe
tempoFileira1 = millis();
}

Leitura do potenciômetro

Criarei uma função chamada void lerPotenciometro().

Detecção da posição

Para detectar a posição do potenciômetro, basta fazer a leitura analógica do pino. E, com base nisso, dividir o valor em três partes. Lembrando, a leitura analógica retorna valores de 0 a 1023 (0 a 5v). Como o valor não é constante e ficar variando mais ou menos 10 unidades, criarei um gap (buraco) entre cada faixa de posição. Defini arbitrariamente as seguintes faixas:

  • Valores de:
    • 0 – 320: posição 2 (potenciômetro para direita no meu caso)
    • 340 – 660: posição 1 (potenciômetro no meio)
    • 680 – 1023: posição 0 (potenciômetro para esquerda no meu caso)

Ou seja, basta fazer a leitura e criar um condicional para testar em qual posição o potenciômetro está. Eu usei a própria variável de leitura para ‘setar’ (definir) a posição do potenciômetro:

int pot = analogRead(controle); 

if(pot >= 680){

pot = 0; //Posição 0

} …

Detectar acerto ou erro do ritmo

Na função anterior, vimos que a variável fileira1 informa em qual posição da sequência os LEDs da fileira 1 estão. Ou seja, basta utilizar essa variável para detectar se a pessoa acertou o ‘ritmo’: se a sequência de acionamento do LED for a 3ª posição e o potenciômetro estiver na posição 0 (deslocado para a esquerda), então o jogador acertou aquela ‘nota’.

Como a parte que detecta se o jogador errou está na função anterior, não precisamos nos preocupar com isso. Exceto, com o fato de que a variável fileira1 deve ser ‘setada’ para 4 (inativa) para que o jogo não reconheça que a pessoa errou. E, para evitar atrasos, a variavel tempoFileira1 deve ser ‘resetada’ sendo igualada a 0.

1
2
3
4
5
6
7
8
if(fileira1 == 3 && pot == 0){ //Se o LED da fileira 1 tiver chegado e a posição do potenciômetro for a 0
    fileira1 = 4; //Deixa a fileria desativada
    digitalWrite(ledsLaranja[2], LOW);
    tempoFileira1 = 0;
    tone(buzzer, 494, 150); //Som para indicar que a pessoa acertou

    placar += ((float)1000/delayFileira1)*25; //A pessoa ganha mais ponto quanto mais rapido for o tempo do LED chegar (quanto menor for o delay entre os acionamento, por isso fica 1/delay)
}

Para acionar o buzzer utilizei a função tone() também. Dessa vez com uma frequência de 494 que corresponde ao ‘Si’, e uma duração de 150ms. A escolha foi aleatória. Por fim, criei uma variável placar (no início do programa) e aqui eu somei um valor a ela. Esse valor é inversamente proporcional ao delay de acionamento da sequência dos LEDs. Isso, pois quanto mais rápido é o acionamento e a pessoa acerta, mais pontos ela merece.

Controle do jogo

Criarei uma função chamada void controleJogo().

Essa função é o coração do jogo. Ela é responsável por ditar o ritmo do jogo, dizendo quando as peças devem aparecer ou não. Essa função tem o mesmo problema da função de acionamento dos LEDs, que é: possui delays e deve funcionar sem atrapalhar o restante do código. A abordagem é a mesma: criar uma variável de tempo (tempoJogo) para auxiliar nesse problema. Aqui o delay entre cada funcionamento também é definido por uma variável, chamada delayJogo:

if (abs(millis()-tempoJogo) > delayJogo){

Como o jogo tem um limite máximo de peças, isso tudo foi envolvido em um condicional para testar se a contagem de ‘notas’ ainda não chegou ao limite:

if(contagem != contagemMax){

Aparecimento de notas

O aparecimento das notas é algo que deve ser aleatório. Portanto, vou aproveitar da função random() do Arduino. Primeiro, precisei adicionar o seguinte comando no setup():

randomSeed(analogRead(1));

Esse comando diz que os números aleatórios serão gerados com base no ruído lido pela porta analógica A1 (já que o pino está desconectado e está flutuando). Agora é só fazer o seguinte: gerar um número aleatório de 0 a 2 (entre 0 e 3). Se for 0, aciona a 1ª fileira, se for 1 aciona a 2ª e se for 2 aciona a 3ª. Para acionar a fileira é só mandar a variável fileira1 para 0 (para o caso da fileira1) e gerar um delay aleatório para a sequência de acionamento.

1
2
3
4
if(aleatorio == 0){
    fileira1 = 0;
    delayFileira1 = random(limiteInf,limiteSup); //Define o delay da fileira como sendo aleatorio
}

Limite inferior e superior são duas variáveis para controlar os valores com base na dificuldade que a pessoa escolhe. No início do código eu defini valores arbitrários para esses limites. Por exemplo, se for a dificuldade médio, o delay varia entre 250 e 500ms.

O outro if dentro dessa parte do código é mais complicado. Mas ele serve basicamente para testar se o número aleatório gerado não foi exatamente o de uma fileira que já está sendo acionada. Se for o caso, ele tenta encontrar a primeira fileira que estiver livre e aciona ela. Se nenhuma estiver livre, o programa não faz nada até o próximo delay.

Fim de jogo

Se a contagem de ‘notas’ estiver chegado no limite, a função verifica se as três fileiras estão no estado final (fileira1, fileira2 e fileira3 são iguais a 4 – que é o estado desativado). Se for o caso, manda uma mensagem no monitor serial mostrando o placar e toca uma musica no buzzer indicando o fim de jogo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
else if(fileira1 == 4 && fileira2 == 4 && fileira3 == 4){
    delay(500);
    Serial.print("Fim de jogo!\nVoce fez: ");
    Serial.print(placar);
    Serial.println(" pontos\nResete a plaquinha para comecar outro jogo.");
    //Toca uma musiquinha pra indicar o fim
    tone(buzzer, 262, 200); //Do
    delay(200);
    tone(buzzer, 294, 200); //Re
    delay(200);
    tone(buzzer, 330, 400); //Mi
    delay(400);
    tone(buzzer, 349, 400); //Fa
    delay(400);
    tone(buzzer, 349, 400); //Fa
    delay(400);
    tone(buzzer, 349, 600); //Fa
    fimDeJogo=true;
}

Código completo

Copie, cole e divirta-se! Se algo não funcionar, veja a explicação do tópico acima, pois o potenciômetro pode estar com as faixas trocadas ou algo assim.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
//Declara as variaveis para controlar os LEDs
int ledsLaranja[3] = {3,4,5};
int ledsVerde[3] = {6,7,8};
int ledsAzul[3] = {9,10,11};

//Define os pinos para o buzzer e o potenciômetro
#define buzzer 2
#define controle A0

//Variaveis para controlar o acionamento dos LEDs
unsigned long tempoFileira1 = 0; //Variaveis auxiliares do tempo entre o acionamento de cada LED
unsigned long tempoFileira2 = 0;
unsigned long tempoFileira3 = 0;
int fileira1=4; //Variaveis para saber a posição dos LEDs
int fileira2=4;
int fileira3=4;
int delayFileira1 = 1000; //Variaveis para comandar o tempo de avanço dos LEDs
int delayFileira2 = 1000;
int delayFileira3 = 1000;

//Variaveis para controlar o jogo
unsigned long tempoJogo=0; //Variavel auxiliar do tempo entre o aparecimento das peças
int delayJogo = 1000; //Delay entre cada aparecimento de peças
long aleatorio = 0; //Variavel auxiliar para os numeros aleatorios
int contagemMax; //Contagem maxima de peças que o jogo terá
int contagem=0; //Contagem de peças que ja passaram
int placar=0; //Pontuação
bool fimDeJogo = false; //Variavel para saber se o jogo acabou

//ESCOLHA A DIFICULDADE AQUI
// 0 - Facil
// 1 - Medio
// 2 - Difícil
int dificuldade = 2;

int limiteInf = 500;
int limiteSup = 1000;

void setup() {
  int i;
  for(i=0; i < 3;i++){ //Define os LEDs como saida
    pinMode(ledsLaranja[i], OUTPUT);
    pinMode(ledsVerde[i], OUTPUT);
    pinMode(ledsAzul[i], OUTPUT);
    digitalWrite(ledsLaranja[i], LOW);
    digitalWrite(ledsVerde[i], LOW);
    digitalWrite(ledsAzul[i], LOW);
  }

  pinMode(buzzer, OUTPUT);
  pinMode(controle, INPUT);

  //Comandos de controle do jogo:
  randomSeed(analogRead(1));//Comando base para ajudar na geração de numeros aleatorios
  contagemMax = random(25,30); //Define a contagem maxima de notas do jogo
  if(dificuldade == 0){
    limiteInf = 750;
    limiteSup = 1000;
  }else if(dificuldade == 1){
    limiteInf = 250;
    limiteSup = 500;
  }else{
    limiteInf = 200;
    limiteSup = 250;
  }


  Serial.begin(9600);
  Serial.print("Prepare-se, pois o jogo esta prestes a comecar...\nA contagem de pecas e: ");
  Serial.println(contagemMax);
  delay(3000);
  Serial.println("Comecou!");
}

void loop() {
  while (fimDeJogo == false){
    controleJogo();
    acionarFileiras();
    lerPotenciometro();
  }  
}

void controleJogo(){
  if(contagem != contagemMax){
    if (abs(millis()-tempoJogo) > delayJogo){
      int aleatorio = random(3);
      if((aleatorio == 0 && fileira1 != 4) || (aleatorio == 1 && fileira2 != 4) || (aleatorio == 2 && fileira3 != 4)){ //Se a fileira escolhida ja estiver ocupada
        //Encontra a primeira fileira livre
        if(fileira1 == 4){
          aleatorio = 0;
        }else if(fileira2 == 4){
          aleatorio = 1;
        }else if(fileira3 == 4){
          aleatorio = 2;
        }else{
          aleatorio = 4; //Se não tiver nenhuma livre, define como 4 e nao faz nada
        }
      }
 
      //Ativa os LEDs (colocando na posiçao 0) da fileira escolhida
      if(aleatorio == 0){
          fileira1 = 0;
          delayFileira1 = random(limiteInf,limiteSup); //Define o delay da fileira como sendo aleatorio
      }else if(aleatorio == 1){
          fileira2 = 0;
          delayFileira2 = random(limiteInf,limiteSup);
      }else if(aleatorio == 2){
          fileira3 = 0;
          delayFileira3 = random(limiteInf,limiteSup);
      }
           
      delayJogo = random(limiteInf,limiteSup); //O delay até o proximo LED varia de 500ms a 1000ms
      tempoJogo = millis();
      if(aleatorio != 4){
        contagem++;
      }
    }
  }else if(fileira1 == 4 && fileira2 == 4 && fileira3 == 4){ //Se a contagem chegou ao limite, espera todas as notas irem até o fim
      delay(500);
      Serial.print("Fim de jogo!\nVoce fez: ");
      Serial.print(placar);
      Serial.println(" pontos\nResete a plaquinha para comecar outro jogo.");
      //Toca uma musiquinha pra indicar o fim
      tone(buzzer, 262, 200); //Do
      delay(200);
      tone(buzzer, 294, 200); //Re
      delay(200);
      tone(buzzer, 330, 400); //Mi
      delay(400);
      tone(buzzer, 349, 400); //Fa
      delay(400);
      tone(buzzer, 349, 400); //Fa
      delay(400);
      tone(buzzer, 349, 600); //Fa
      fimDeJogo=true;
   }
}

void lerPotenciometro(){ //Função que retorna a posição do controle (potenciômetro)
  //Faixas:
  //0 - 320 retorna 0
  //340 - 660 retorna 1
  //680 - 1023 retorna 2
 
  int pot = analogRead(controle); //Lê o potenciômetro
 
  if(pot >= 680){ //Se for maior que 680
    pot = 0;
  }else if(pot >= 340 && pot <= 660){ //Se for maior que 340 e menor que 660
    pot = 1;
  }else if(pot <=320){ //Se for menor que 320
    pot = 2;
  }

  if(fileira1 == 3 && pot == 0){ //Se o LED da fileira 1 tiver chegado e a posição do potenciômetro for a 0
    fileira1 = 4; //Deixa a fileria desativada
    digitalWrite(ledsLaranja[2], LOW);
    tempoFileira1 = 0;
    tone(buzzer, 494, 150); //Som para indicar que a pessoa acertou

    placar += ((float)1000/delayFileira1)*25; //A pessoa ganha mais ponto quanto mais rapido for o tempo do LED chegar (quanto menor for o delay entre os acionamento, por isso fica 1/delay)
  }

  if(fileira2 == 3 && pot == 1){ //Se o LED da fileira 1 tiver chegado e a posição do potenciômetro for a 0
    fileira2 = 4; //Deixa a fileria desativada
    digitalWrite(ledsVerde[2], LOW);
    tempoFileira2 = 0;
    tone(buzzer, 494, 150); //Som para indicar que a pessoa acertou

    placar += ((float)1000/delayFileira2)*25; //A pessoa ganha mais ponto quanto mais rapido for o tempo do LED chegar (quanto menor for o delay entre os acionamento, por isso fica 1/delay)
  }

  if(fileira3 == 3 && pot == 2){ //Se o LED da fileira 1 tiver chegado e a posição do potenciômetro for a 0
    fileira3 = 4; //Deixa a fileria desativada
    digitalWrite(ledsAzul[2], LOW);
    tempoFileira3 = 0;
    tone(buzzer, 494, 150); //Som para indicar que a pessoa acertou

    placar += ((float)1000/delayFileira3)*25; //A pessoa ganha mais ponto quanto mais rapido for o tempo do LED chegar (quanto menor for o delay entre os acionamento, por isso fica 1/delay)
  }
 
}

void acionarFileiras(){
  if(abs(millis()-tempoFileira1) > delayFileira1){ //Primeira fileira
    if (fileira1 < 3){ //Garante que o ultimo acionamento nao atrapalhe
     tempoFileira1 = millis();
    }
   
    if(fileira1 == 0){
      digitalWrite(ledsLaranja[0], HIGH);
      digitalWrite(ledsLaranja[2], LOW);
      fileira1 ++;
    }else if(fileira1 == 1){
      digitalWrite(ledsLaranja[0], LOW);
      digitalWrite(ledsLaranja[1], HIGH);
      fileira1 ++;
    }else if(fileira1 == 2){
      digitalWrite(ledsLaranja[1], LOW);
      digitalWrite(ledsLaranja[2], HIGH);
      fileira1 ++;
    }else if(fileira1 == 3){
      digitalWrite(ledsLaranja[2], LOW);
      tone(buzzer, 370, 200); //Som para indicar que a pessoa 'perdeu' o LED
      fileira1 ++;
    }
   
  }
 
  if(abs(millis()-tempoFileira2) > delayFileira2){ //Segunda fileira
    if (fileira2 < 3){ //Garante que o ultimo acionamento nao atrapalhe
     tempoFileira2 = millis();
    }
   
    if(fileira2 == 0){
      digitalWrite(ledsVerde[0], HIGH);
      digitalWrite(ledsVerde[2], LOW);
      fileira2 ++;
    }else if(fileira2 == 1){
      digitalWrite(ledsVerde[0], LOW);
      digitalWrite(ledsVerde[1], HIGH);
      fileira2 ++;
    }else if(fileira2 == 2){
      digitalWrite(ledsVerde[1], LOW);
      digitalWrite(ledsVerde[2], HIGH);
      fileira2 ++;
    }else if(fileira2 == 3){
      digitalWrite(ledsVerde[2], LOW);
      tone(buzzer, 370, 200); //Som para indicar que a pessoa 'perdeu' o LED
      fileira2 ++;
    }
  }

  if(abs(millis()-tempoFileira3) > delayFileira3){ //Terceira fileira
    if (fileira3 < 3){ //Garante que o ultimo acionamento nao atrapalhe
     tempoFileira3 = millis();
    }
   
    if(fileira3 == 0){
      digitalWrite(ledsAzul[0], HIGH);
      digitalWrite(ledsAzul[2], LOW);
      fileira3 ++;
    }else if(fileira3 == 1){
      digitalWrite(ledsAzul[0], LOW);
      digitalWrite(ledsAzul[1], HIGH);
      fileira3 ++;
    }else if(fileira3 == 2){
      digitalWrite(ledsAzul[1], LOW);
      digitalWrite(ledsAzul[2], HIGH);
      fileira3 ++;
    }else if(fileira3 == 3){
      digitalWrite(ledsAzul[2], LOW);
      tone(buzzer, 370, 200); //Som para indicar que a pessoa 'perdeu' o LED
      fileira3 ++;
    }
  }
}