Simon Dice

Primer Poyecto: Juego Simón Dice - Botones, LEDs, Buzzer

Nov 15, 2019

•

16040 views

•

0 respects

lights

kids

games

Components and supplies

Male/Male Jumper Wires

Tactile Switch, Top Actuated

Resistor 10k ohm

Buzzer

Resistor 221 ohm

LED (generic)

Arduino UNO

Resistor 100 ohm

Project description

Code

GGA_Simon_Dice.ino

arduino

1/* Este sketch en una versin del juego "Simon Dice"
2  Existe un botn  de inicio que hay que pulsar para empezar la partida
3  Cuatro LEDs de colores  para mostrar las secuencias
4  Cuatro botones para que el jugador reproduzca la  secuencia
5
6  Al iniciar una partida se reproduce una secuencia de bienvenida  al juego
7  y tras un segundo se muestra la primera secuencia de 1 luz
8
9  El jugador debe repetir la secuencia mostrada
10
11  Si seacierta la secuencia,  todos los LEDs se encienden durante 1 segundo
12  y despues se muestra la nueva  secuencia.
13  Cada jugada la secuencia se incrementa en una luz ms y se incrementa  la velocidad
14  en que se muestra lasecuencia para hacer ms dificil el juego.
15
16  Si se falla loscuatro LEDs patpadearn 3 veces y finalizar la partida.
17
18  Hardware necesario:
19  4 LEDs (1 verde, 1 amarillo,1 azul y 1 rojo)
20  4 resistencias  220ohm (para los LEDs)
21  5 botones/pulsadores de 4 patas
22  5 resistencias  10Kohm (para los botones que se montarn como resistencias PullUp)
23  1 zumbador  pasivo (passive buzzer)
24  1 resistencia de 100ohm (para el zumbador)
25  Cables  para conexin a placa arduino y para conexiones en protoboard
26*/
27
28
29//  definimos constantes para los diferentes pines que usamos
30const byte PIN_LED_VERDE  = 5;
31const byte PIN_LED_AMARILLO = 4;
32const byte PIN_LED_AZUL = 3;
33const  byte PIN_LED_ROJO = 2;
34
35const byte PIN_BOTON_VERDE = 6;
36const byte PIN_BOTON_AMARILLO  = 7;
37const byte PIN_BOTON_AZUL = 8;
38const byte PIN_BOTON_ROJO = 9;
39
40const  byte PIN_BOTON_INICIO = 10;
41
42const byte PIN_ZUMBADOR = 11;
43
44const byte  MAX_RONDAS = 255; // el nmero mximo de rondas ser de 255
45
46const int VELOCIDAD_INICIAL  = 1000; // velocidad inicial en milisegundos a la que se mostrar la secuencia
47
48byte  ronda = 0; //numero de ronda en la que vamos
49byte secuencia[MAX_RONDAS + 1];  //array para alojar la secuencia que se va generando. El array empieza en el elemento  0 pero no lo usamos, empezamos en el 1 para hacer coincidir con el nmero de ronda
50int  velocidad = VELOCIDAD_INICIAL; // tiempo en milisegundos que permanecen encendidos  los LEDs cuando muestra la secuencia a repetir
51
52// Definimos notas musicales,  duraciones y Variable tempo
53#define NOTA_B3 246.94 // Si en 3 Octava
54#define  NOTA_C4 261.63 // Do en 4 Octava
55#define NOTA_C4S 277.18 // Do # en 4 Octava
56#define  NOTA_D4 293.66 // Re en 4 Octava
57#define NOTA_E4 329.63 // Mi en 4 Octava
58#define  NOTA_F4 349.23 // Fa en 4 Octava
59
60#define T_NEGRA 1
61#define T_BLANCA 2
62#define  T_REDONDA 4
63#define T_CORCHEA 0.5
64#define T_SEMICORCHEA 0.25
65#define T_FUSA  0.125
66#define T_SEMIFUSA 0.0625
67
68int tempo = 150; // duracin de un pulso  en milisegundos. Se usa para la duracin de las notas
69
70// variables para el  controlde rebotes / bouncing de los pulsadores. Cada uno de los 4 pulsadores tiene  las suyas
71long rebote_ultima_senal_verde = 0; //momento en el que se produjo  la seal anterior del boton
72long rebote_ultima_senal_amarillo = 0; 
73long rebote_ultima_senal_azul  = 0; 
74long rebote_ultima_senal_rojo = 0; 
75long rebote_retardo = 50; // tiempo  en milisegundos transcurrido que si se supera entre dos seales del botn deja de  considerarse un rebote
76
77void setup() {
78  // establecemos los pines de los  botones en modo entrada
79  pinMode(PIN_BOTON_VERDE, INPUT);
80  pinMode(PIN_BOTON_AMARILLO,  INPUT);
81  pinMode(PIN_BOTON_AZUL, INPUT);
82  pinMode(PIN_BOTON_ROJO, INPUT);
83  pinMode(PIN_BOTON_INICIO, INPUT);
84  // establecemos los pines de los LEDs en  modo salida
85  pinMode(PIN_LED_VERDE, OUTPUT);
86  pinMode(PIN_LED_AMARILLO,  OUTPUT);
87  pinMode(PIN_LED_AZUL, OUTPUT);
88  pinMode(PIN_LED_ROJO, OUTPUT);
89  // establecemos el pin del buzzer/zumbador en modo salida
90  pinMode(PIN_ZUMBADOR,  OUTPUT);
91  // inicializamos las salidasa a LOW
92  digitalWrite(PIN_LED_VERDE,  LOW);
93  digitalWrite(PIN_LED_AMARILLO, LOW);
94  digitalWrite(PIN_LED_AZUL,  LOW);
95  digitalWrite(PIN_LED_ROJO, LOW);
96
97  // inicializamos las entradas  a HIGH ya que hemos diseado el circuito con botones con resistencia pullUp
98  digitalWrite(PIN_BOTON_VERDE,  HIGH);
99  digitalWrite(PIN_BOTON_AMARILLO, HIGH);
100  digitalWrite(PIN_BOTON_AZUL,  HIGH);
101  digitalWrite(PIN_BOTON_ROJO, HIGH);
102  digitalWrite(PIN_BOTON_INICIO,  HIGH);
103
104  //Serial.begin(9600);
105}
106
107void loop()
108{
109  if (ronda  == 0) { // si la ronda es 0 es que aun no han pulsado el botn de inicio para empezar  una partida nueva
110    espera_pulsacion_inicio();
111  }
112  if (ronda == 1)  { // si estamos en la primera ronda hacemos las seales de bienvenida
113    flash_bienvenida();
114  }
115  genera_secuencia(); //generamos la secuencia con tantos elementos como  el nmero de ronda en el que vamos
116  lee_respuesta(); //leemos la respuesta del  jugador
117}
118
119
120void espera_pulsacion_inicio() {
121  // esperamos hasta  que pulsen el boton de inico de nueva partida
122  while (ronda == 0) {
123    if  (digitalRead(PIN_BOTON_INICIO) == LOW) {
124      delay(500);
125      ronda = 1;
126      delay(50);
127    }
128  }
129}
130
131void reproduce_melodia(int notas[],  int duracion[], int tempo, int nro_notas) {
132  /* notas = array con las notas  (frecuencias o notas pre-definidas)
133     duracion = array con la duracin de cada  nota del array notas[] son el factor multiplicador del tempo, es decir si queremos  que dure un pulso de tempo, indicaremos 1 o T_NEGRA
134     tempo = duracin de un  pulso (una nota negra) en milisegundos
135     nro_notas = numero de notas que compone  el array notas[]
136   */
137  int x = 0;
138  for (x = 0; x < nro_notas; x++) {
139    tone(PIN_ZUMBADOR, notas[x], duracion[x] * tempo);
140    delay(duracion[x]  * tempo * 1.30);
141  }
142}
143
144void reproduce_nota_led(byte led, int tiempo){
145  int nota[] ={NOTA_C4, NOTA_D4, NOTA_E4, NOTA_F4};
146  tone(PIN_ZUMBADOR, nota[led  - 2], tiempo); // HACEMOS nota[led - 2] por que en led pasamos el pin del led que  toque encender y estos empiezan en el pin 2
147  delay(tiempo); // hacemos delay  para que el led permanezca encendido mientras suena la nota
148}
149
150void tema_inicio()  {
151  // meloda que suena al inicio de las partidas
152  int notas[] = {NOTA_B3,  NOTA_B3,  NOTA_B3, NOTA_D4, NOTA_B3, NOTA_D4};
153  int duracion[] = {T_NEGRA, T_NEGRA,  T_NEGRA, T_BLANCA, T_NEGRA, T_REDONDA};
154  //tempo = 150;
155  // reproducimos  la meloda
156  reproduce_melodia (notas, duracion, 100, 6);
157}
158
159void tema_game_over  (){
160  //meloda que suena al perder la partida
161  int notas[] = {NOTA_D4, NOTA_C4S,  NOTA_C4, NOTA_B3};
162  int duracion[] = {T_NEGRA, T_NEGRA, T_NEGRA, T_REDONDA};
163  reproduce_melodia (notas, duracion, 300, 4);
164}
165
166void flash_bienvenida()  {
167  // Hacemos una secuencia de luces de inicio de partida
168  for (byte x =  2; x <= 5; x++)
169  {
170    digitalWrite(x, HIGH);
171    delay(100);
172  }
173  for (byte x = 5; x >= 2; x--)
174  {
175    digitalWrite(x, LOW);
176    delay(100);
177  }
178  for (byte y = 1; y <= 3; y++)
179  {
180    for (byte x = 2; x <= 5; x++)
181    {
182      digitalWrite(x, HIGH);
183    }
184    delay (333);
185    for (byte  x = 5; x >= 2; x--)
186    {
187      digitalWrite(x, LOW);
188    }
189  }
190  // y Sunena la meloda de inicio
191  tema_inicio();
192  delay (1000);
193}
194
195void  flash_respuesta_correcta() {
196  // esperamos 1 segundo para continuar con la siguiente  secuencia
197  delay (1000);
198}
199
200void flash_respuesta_incorrecta() {
201  // Suena la meloda game over con los 4 leds encendidos
202  delay(500);
203  for  (byte x = 2; x <= 5; x++)
204    {
205      digitalWrite(x, HIGH);
206    }  
207  tema_game_over();
208  for (byte x = 5; x >= 2; x--)
209    {
210      digitalWrite(x,  LOW);
211    }
212  delay(1000);
213}
214
215
216void genera_secuencia() {
217  //  Generamos el sigeuinte elemento de la secuncia y la reproducimos
218  randomSeed(analogRead(0));  // generamos una semilla para generar el nmero aleatorio
219  secuencia[ronda] =  random(2, 5); //generamos un numero aleatorio entre 2 y 5 que son lospines dondea  estn los leds
220  for (int x = 1; x <= ronda; x++) // reproducimos la secuencia
221  {
222    digitalWrite(secuencia[x], HIGH);
223    reproduce_nota_led(secuencia[x],  velocidad);
224    //delay(velocidad); 
225    digitalWrite(secuencia[x], LOW);
226    delay(100 * velocidad / VELOCIDAD_INICIAL);
227  }
228}
229
230
231
232void  lee_respuesta() {
233  // leemos las pulsaciones del jugador y vamos comprobando  que la secuencia sea correcta
234  boolean correcto = true;
235  byte x = 1;
236  byte pulsacion = 0;
237  while (correcto and x <= ronda)
238  { //vamos leyendo  pulsacion a pulsacin y comprobando que la secuencia vaya siendo correcta
239    if  (digitalRead(PIN_BOTON_ROJO) == LOW) {
240      digitalWrite(PIN_LED_ROJO, HIGH);
241      reproduce_nota_led(PIN_LED_ROJO, 250);
242      digitalWrite(PIN_LED_ROJO,  LOW);
243      pulsacion = PIN_LED_ROJO;
244      rebote_ultima_senal_rojo = millis();
245    }
246    else if (digitalRead(PIN_BOTON_AZUL) == LOW) {
247      digitalWrite(PIN_LED_AZUL,  HIGH);
248      reproduce_nota_led(PIN_LED_AZUL, 250);
249      digitalWrite(PIN_LED_AZUL,  LOW);
250      pulsacion = PIN_LED_AZUL;
251      rebote_ultima_senal_azul = millis();
252    }
253    else if (digitalRead(PIN_BOTON_AMARILLO) == LOW) {
254      digitalWrite(PIN_LED_AMARILLO,  HIGH);
255      reproduce_nota_led(PIN_LED_AMARILLO, 250);
256      digitalWrite(PIN_LED_AMARILLO,  LOW);
257      pulsacion = PIN_LED_AMARILLO;
258      rebote_ultima_senal_amarillo  = millis();
259    }
260    else if (digitalRead(PIN_BOTON_VERDE) == LOW) {
261      digitalWrite(PIN_LED_VERDE, HIGH);
262      reproduce_nota_led(PIN_LED_VERDE,  250);
263      digitalWrite(PIN_LED_VERDE, LOW);
264      pulsacion = PIN_LED_VERDE;
265      rebote_ultima_senal_verde = millis();
266    }
267  
268
269    if ((pulsacion  == PIN_LED_ROJO && (millis() - rebote_ultima_senal_rojo) > rebote_retardo) || 
270        (pulsacion == PIN_LED_AZUL && (millis() - rebote_ultima_senal_azul) > rebote_retardo)  || 
271        (pulsacion == PIN_LED_AMARILLO && (millis() - rebote_ultima_senal_amarillo)  > rebote_retardo) || 
272        (pulsacion == PIN_LED_VERDE && (millis() - rebote_ultima_senal_verde)  > rebote_retardo)){  
273         // Solo entramos en caso de que se haya pulsado  un boton y ya se haya soltado, 
274         // para saber si se solt de verdad utilizamos  las comparaciones de rebote para evitar falsas sueltas del botn
275      if (pulsacion  != secuencia[x]) { //si se ha fallado correcto = false y se sale del bucle
276        correcto  = false;
277      }
278      else { //si no se ha fallado se pasa al siguiente elemento  de la secuencia
279        x++;
280        pulsacion = 0;
281      }
282    }
283  } //fin while
284
285  if (correcto == true) { //si correcto es que se ha acertado  toda la secuencia
286    delay(500);
287    flash_respuesta_correcta();
288    ronda++;  //incrementamos una ronda
289    if (velocidad >= 50) {
290      velocidad = velocidad  - 50; // incrementamos la velocidad de muestra de la secuencia (10 milisegundos  ms rpida)
291    }
292  }
293  else { //si correcto == false es que se ha fallado
294    flash_respuesta_incorrecta();
295    ronda = 0; //ponemos ronda a 0 para volver  a esperar que inicien una nueva partida
296    velocidad = VELOCIDAD_INICIAL;
297    espera_pulsacion_inicio();
298  }
299}
300

/* Este sketch en una versin del juego "Simon Dice"
  Existe un botn  de inicio que hay que pulsar para empezar la partida
  Cuatro LEDs de colores  para mostrar las secuencias
  Cuatro botones para que el jugador reproduzca la  secuencia

  Al iniciar una partida se reproduce una secuencia de bienvenida  al juego
  y tras un segundo se muestra la primera secuencia de 1 luz

  El jugador debe repetir la secuencia mostrada

  Si seacierta la secuencia,  todos los LEDs se encienden durante 1 segundo
  y despues se muestra la nueva  secuencia.
  Cada jugada la secuencia se incrementa en una luz ms y se incrementa  la velocidad
  en que se muestra lasecuencia para hacer ms dificil el juego.

  Si se falla loscuatro LEDs patpadearn 3 veces y finalizar la partida.

  Hardware necesario:
  4 LEDs (1 verde, 1 amarillo,1 azul y 1 rojo)
  4 resistencias  220ohm (para los LEDs)
  5 botones/pulsadores de 4 patas
  5 resistencias  10Kohm (para los botones que se montarn como resistencias PullUp)
  1 zumbador  pasivo (passive buzzer)
  1 resistencia de 100ohm (para el zumbador)
  Cables  para conexin a placa arduino y para conexiones en protoboard
*/


//  definimos constantes para los diferentes pines que usamos
const byte PIN_LED_VERDE  = 5;
const byte PIN_LED_AMARILLO = 4;
const byte PIN_LED_AZUL = 3;
const  byte PIN_LED_ROJO = 2;

const byte PIN_BOTON_VERDE = 6;
const byte PIN_BOTON_AMARILLO  = 7;
const byte PIN_BOTON_AZUL = 8;
const byte PIN_BOTON_ROJO = 9;

const  byte PIN_BOTON_INICIO = 10;

const byte PIN_ZUMBADOR = 11;

const byte  MAX_RONDAS = 255; // el nmero mximo de rondas ser de 255

const int VELOCIDAD_INICIAL  = 1000; // velocidad inicial en milisegundos a la que se mostrar la secuencia

byte  ronda = 0; //numero de ronda en la que vamos
byte secuencia[MAX_RONDAS + 1];  //array para alojar la secuencia que se va generando. El array empieza en el elemento  0 pero no lo usamos, empezamos en el 1 para hacer coincidir con el nmero de ronda
int  velocidad = VELOCIDAD_INICIAL; // tiempo en milisegundos que permanecen encendidos  los LEDs cuando muestra la secuencia a repetir

// Definimos notas musicales,  duraciones y Variable tempo
#define NOTA_B3 246.94 // Si en 3 Octava
#define  NOTA_C4 261.63 // Do en 4 Octava
#define NOTA_C4S 277.18 // Do # en 4 Octava
#define  NOTA_D4 293.66 // Re en 4 Octava
#define NOTA_E4 329.63 // Mi en 4 Octava
#define  NOTA_F4 349.23 // Fa en 4 Octava

#define T_NEGRA 1
#define T_BLANCA 2
#define  T_REDONDA 4
#define T_CORCHEA 0.5
#define T_SEMICORCHEA 0.25
#define T_FUSA  0.125
#define T_SEMIFUSA 0.0625

int tempo = 150; // duracin de un pulso  en milisegundos. Se usa para la duracin de las notas

// variables para el  controlde rebotes / bouncing de los pulsadores. Cada uno de los 4 pulsadores tiene  las suyas
long rebote_ultima_senal_verde = 0; //momento en el que se produjo  la seal anterior del boton
long rebote_ultima_senal_amarillo = 0; 
long rebote_ultima_senal_azul  = 0; 
long rebote_ultima_senal_rojo = 0; 
long rebote_retardo = 50; // tiempo  en milisegundos transcurrido que si se supera entre dos seales del botn deja de  considerarse un rebote

void setup() {
  // establecemos los pines de los  botones en modo entrada
  pinMode(PIN_BOTON_VERDE, INPUT);
  pinMode(PIN_BOTON_AMARILLO,  INPUT);
  pinMode(PIN_BOTON_AZUL, INPUT);
  pinMode(PIN_BOTON_ROJO, INPUT);
  pinMode(PIN_BOTON_INICIO, INPUT);
  // establecemos los pines de los LEDs en  modo salida
  pinMode(PIN_LED_VERDE, OUTPUT);
  pinMode(PIN_LED_AMARILLO,  OUTPUT);
  pinMode(PIN_LED_AZUL, OUTPUT);
  pinMode(PIN_LED_ROJO, OUTPUT);
  // establecemos el pin del buzzer/zumbador en modo salida
  pinMode(PIN_ZUMBADOR,  OUTPUT);
  // inicializamos las salidasa a LOW
  digitalWrite(PIN_LED_VERDE,  LOW);
  digitalWrite(PIN_LED_AMARILLO, LOW);
  digitalWrite(PIN_LED_AZUL,  LOW);
  digitalWrite(PIN_LED_ROJO, LOW);

  // inicializamos las entradas  a HIGH ya que hemos diseado el circuito con botones con resistencia pullUp
  digitalWrite(PIN_BOTON_VERDE,  HIGH);
  digitalWrite(PIN_BOTON_AMARILLO, HIGH);
  digitalWrite(PIN_BOTON_AZUL,  HIGH);
  digitalWrite(PIN_BOTON_ROJO, HIGH);
  digitalWrite(PIN_BOTON_INICIO,  HIGH);

  //Serial.begin(9600);
}

void loop()
{
  if (ronda  == 0) { // si la ronda es 0 es que aun no han pulsado el botn de inicio para empezar  una partida nueva
    espera_pulsacion_inicio();
  }
  if (ronda == 1)  { // si estamos en la primera ronda hacemos las seales de bienvenida
    flash_bienvenida();
  }
  genera_secuencia(); //generamos la secuencia con tantos elementos como  el nmero de ronda en el que vamos
  lee_respuesta(); //leemos la respuesta del  jugador
}


void espera_pulsacion_inicio() {
  // esperamos hasta  que pulsen el boton de inico de nueva partida
  while (ronda == 0) {
    if  (digitalRead(PIN_BOTON_INICIO) == LOW) {
      delay(500);
      ronda = 1;
      delay(50);
    }
  }
}

void reproduce_melodia(int notas[],  int duracion[], int tempo, int nro_notas) {
  /* notas = array con las notas  (frecuencias o notas pre-definidas)
     duracion = array con la duracin de cada  nota del array notas[] son el factor multiplicador del tempo, es decir si queremos  que dure un pulso de tempo, indicaremos 1 o T_NEGRA
     tempo = duracin de un  pulso (una nota negra) en milisegundos
     nro_notas = numero de notas que compone  el array notas[]
   */
  int x = 0;
  for (x = 0; x < nro_notas; x++) {
    tone(PIN_ZUMBADOR, notas[x], duracion[x] * tempo);
    delay(duracion[x]  * tempo * 1.30);
  }
}

void reproduce_nota_led(byte led, int tiempo){
  int nota[] ={NOTA_C4, NOTA_D4, NOTA_E4, NOTA_F4};
  tone(PIN_ZUMBADOR, nota[led  - 2], tiempo); // HACEMOS nota[led - 2] por que en led pasamos el pin del led que  toque encender y estos empiezan en el pin 2
  delay(tiempo); // hacemos delay  para que el led permanezca encendido mientras suena la nota
}

void tema_inicio()  {
  // meloda que suena al inicio de las partidas
  int notas[] = {NOTA_B3,  NOTA_B3,  NOTA_B3, NOTA_D4, NOTA_B3, NOTA_D4};
  int duracion[] = {T_NEGRA, T_NEGRA,  T_NEGRA, T_BLANCA, T_NEGRA, T_REDONDA};
  //tempo = 150;
  // reproducimos  la meloda
  reproduce_melodia (notas, duracion, 100, 6);
}

void tema_game_over  (){
  //meloda que suena al perder la partida
  int notas[] = {NOTA_D4, NOTA_C4S,  NOTA_C4, NOTA_B3};
  int duracion[] = {T_NEGRA, T_NEGRA, T_NEGRA, T_REDONDA};
  reproduce_melodia (notas, duracion, 300, 4);
}

void flash_bienvenida()  {
  // Hacemos una secuencia de luces de inicio de partida
  for (byte x =  2; x <= 5; x++)
  {
    digitalWrite(x, HIGH);
    delay(100);
  }
  for (byte x = 5; x >= 2; x--)
  {
    digitalWrite(x, LOW);
    delay(100);
  }
  for (byte y = 1; y <= 3; y++)
  {
    for (byte x = 2; x <= 5; x++)
    {
      digitalWrite(x, HIGH);
    }
    delay (333);
    for (byte  x = 5; x >= 2; x--)
    {
      digitalWrite(x, LOW);
    }
  }
  // y Sunena la meloda de inicio
  tema_inicio();
  delay (1000);
}

void  flash_respuesta_correcta() {
  // esperamos 1 segundo para continuar con la siguiente  secuencia
  delay (1000);
}

void flash_respuesta_incorrecta() {
  // Suena la meloda game over con los 4 leds encendidos
  delay(500);
  for  (byte x = 2; x <= 5; x++)
    {
      digitalWrite(x, HIGH);
    }  
  tema_game_over();
  for (byte x = 5; x >= 2; x--)
    {
      digitalWrite(x,  LOW);
    }
  delay(1000);
}


void genera_secuencia() {
  //  Generamos el sigeuinte elemento de la secuncia y la reproducimos
  randomSeed(analogRead(0));  // generamos una semilla para generar el nmero aleatorio
  secuencia[ronda] =  random(2, 5); //generamos un numero aleatorio entre 2 y 5 que son lospines dondea  estn los leds
  for (int x = 1; x <= ronda; x++) // reproducimos la secuencia
  {
    digitalWrite(secuencia[x], HIGH);
    reproduce_nota_led(secuencia[x],  velocidad);
    //delay(velocidad); 
    digitalWrite(secuencia[x], LOW);
    delay(100 * velocidad / VELOCIDAD_INICIAL);
  }
}



void  lee_respuesta() {
  // leemos las pulsaciones del jugador y vamos comprobando  que la secuencia sea correcta
  boolean correcto = true;
  byte x = 1;
  byte pulsacion = 0;
  while (correcto and x <= ronda)
  { //vamos leyendo  pulsacion a pulsacin y comprobando que la secuencia vaya siendo correcta
    if  (digitalRead(PIN_BOTON_ROJO) == LOW) {
      digitalWrite(PIN_LED_ROJO, HIGH);
      reproduce_nota_led(PIN_LED_ROJO, 250);
      digitalWrite(PIN_LED_ROJO,  LOW);
      pulsacion = PIN_LED_ROJO;
      rebote_ultima_senal_rojo = millis();
    }
    else if (digitalRead(PIN_BOTON_AZUL) == LOW) {
      digitalWrite(PIN_LED_AZUL,  HIGH);
      reproduce_nota_led(PIN_LED_AZUL, 250);
      digitalWrite(PIN_LED_AZUL,  LOW);
      pulsacion = PIN_LED_AZUL;
      rebote_ultima_senal_azul = millis();
    }
    else if (digitalRead(PIN_BOTON_AMARILLO) == LOW) {
      digitalWrite(PIN_LED_AMARILLO,  HIGH);
      reproduce_nota_led(PIN_LED_AMARILLO, 250);
      digitalWrite(PIN_LED_AMARILLO,  LOW);
      pulsacion = PIN_LED_AMARILLO;
      rebote_ultima_senal_amarillo  = millis();
    }
    else if (digitalRead(PIN_BOTON_VERDE) == LOW) {
      digitalWrite(PIN_LED_VERDE, HIGH);
      reproduce_nota_led(PIN_LED_VERDE,  250);
      digitalWrite(PIN_LED_VERDE, LOW);
      pulsacion = PIN_LED_VERDE;
      rebote_ultima_senal_verde = millis();
    }
  

    if ((pulsacion  == PIN_LED_ROJO && (millis() - rebote_ultima_senal_rojo) > rebote_retardo) || 
        (pulsacion == PIN_LED_AZUL && (millis() - rebote_ultima_senal_azul) > rebote_retardo)  || 
        (pulsacion == PIN_LED_AMARILLO && (millis() - rebote_ultima_senal_amarillo)  > rebote_retardo) || 
        (pulsacion == PIN_LED_VERDE && (millis() - rebote_ultima_senal_verde)  > rebote_retardo)){  
         // Solo entramos en caso de que se haya pulsado  un boton y ya se haya soltado, 
         // para saber si se solt de verdad utilizamos  las comparaciones de rebote para evitar falsas sueltas del botn
      if (pulsacion  != secuencia[x]) { //si se ha fallado correcto = false y se sale del bucle
        correcto  = false;
      }
      else { //si no se ha fallado se pasa al siguiente elemento  de la secuencia
        x++;
        pulsacion = 0;
      }
    }
  } //fin while

  if (correcto == true) { //si correcto es que se ha acertado  toda la secuencia
    delay(500);
    flash_respuesta_correcta();
    ronda++;  //incrementamos una ronda
    if (velocidad >= 50) {
      velocidad = velocidad  - 50; // incrementamos la velocidad de muestra de la secuencia (10 milisegundos  ms rpida)
    }
  }
  else { //si correcto == false es que se ha fallado
    flash_respuesta_incorrecta();
    ronda = 0; //ponemos ronda a 0 para volver  a esperar que inicien una nueva partida
    velocidad = VELOCIDAD_INICIAL;
    espera_pulsacion_inicio();
  }
}

Downloadable files

gga_simondice_bb_fMDKhtZ8Gt.jpg

Comments

Only logged in users can leave comments

Gonza_VGO

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content