Simon Dice

/* 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();
  }
}