El Código

​

//---------------------------------------------------------------
//   Constantes publicas para las notas
//---------------------------------------------------------------
#define Nota_B0 31
#define Nota_C1 33
#define Nota_CS1 35
#define Nota_D1 37
#define Nota_DS1 39
#define Nota_E1 41
#define Nota_F1 44
#define Nota_FS1 46
#define Nota_G1 49
#define Nota_GS1 52
#define Nota_A1 55
#define Nota_AS1 58
#define Nota_B1 62
#define Nota_C2 65
#define Nota_CS2 69
#define Nota_D2 73
#define Nota_DS2 78
#define Nota_E2 82
#define Nota_F2 87
#define Nota_FS2 93
#define Nota_G2 98
#define Nota_GS2 104
#define Nota_A2 110
#define Nota_AS2 117
#define Nota_B2 123
#define Nota_C3 131
#define Nota_CS3 139
#define Nota_D3 147
#define Nota_DS3 156
#define Nota_E3 165
#define Nota_F3 175
#define Nota_FS3 185
#define Nota_G3 196
#define Nota_GS3 208
#define Nota_A3 220
#define Nota_AS3 233
#define Nota_B3 247
#define Nota_C4 262
#define Nota_CS4 277
#define Nota_D4 294
#define Nota_DS4 311
#define Nota_E4 330
#define Nota_F4 349
#define Nota_FS4 370
#define Nota_G4 392
#define Nota_GS4 415
#define Nota_A4 440
#define Nota_AS4 466
#define Nota_B4 494
#define Nota_C5 523
#define Nota_CS5 554
#define Nota_D5 587
#define Nota_DS5 622
#define Nota_E5 659
#define Nota_F5 698
#define Nota_FS5 740
#define Nota_G5 784
#define Nota_GS5 831
#define Nota_A5 880
#define Nota_AS5 932
#define Nota_B5 988
#define Nota_C6 1047
#define Nota_CS6 1109
#define Nota_D6 1175
#define Nota_DS6 1245
#define Nota_E6 1319
#define Nota_F6 1397
#define Nota_FS6 1480
#define Nota_G6 1568
#define Nota_GS6 1661
#define Nota_A6 1760
#define Nota_AS6 1865
#define Nota_B6 1976
#define Nota_C7 2093
#define Nota_CS7 2217
#define Nota_D7 2349
#define Nota_DS7 2489
#define Nota_E7 2637
#define Nota_F7 2794
#define Nota_FS7 2960
#define Nota_G7 3136
#define Nota_GS7 3322
#define Nota_A7 3520
#define Nota_AS7 3729
#define Nota_B7 3951
#define Nota_C8 4186
#define Nota_CS8 4435
#define Nota_D8 4699
#define Nota_DS8 4978
//---------------------------------------------------------------
#define EleccionOFF      0 //   Se utiliza para controlar los LED
//---------------------------------------------------------------
#define NingunaEleccion     0 //   Se utiliza para comprobar los botones
//---------------------------------------------------------------
#define EleccionRojo  (1 << 0)
//---------------------------------------------------------------
#define EleccionVerde    (1 << 1)
//---------------------------------------------------------------
#define EleccionAzul (1 << 2)
//---------------------------------------------------------------
#define EleccionAmarillo   (1 << 3)
//---------------------------------------------------------------
#define LedRojo     2
//---------------------------------------------------------------
#define LedVerde   7
//---------------------------------------------------------------
#define LedAzul    3
//---------------------------------------------------------------
#define LedAmarillo  4
//---------------------------------------------------------------
// Definiciones de pin de botones
//---------------------------------------------------------------
#define BotonRojo    9
//---------------------------------------------------------------
#define BotonVerde  12
//---------------------------------------------------------------
#define BotonAzul   10
//---------------------------------------------------------------
#define BotonAmarillo 11
//---------------------------------------------------------------
// Definiciones de pin de zumbador
//---------------------------------------------------------------
#define BUZZER1  6
//---------------------------------------------------------------
#define BUZZER2  5
//---------------------------------------------------------------
// Definir parametros del juego
//---------------------------------------------------------------
#define RondasParaGanar      13 // Número de rondas para recordar con éxito antes de ganar. 13 es factible.
//---------------------------------------------------------------
#define LimiteTiempo   3000 // Cantidad de tiempo para presionar un botón antes de que termine el juego. 3000 ms = 3 seg
//---------------------------------------------------------------
#define ModoMemoria  0
//---------------------------------------------------------------
#define ModoBatalla  1
//---------------------------------------------------------------
#define ModoBeeGrees 2
//---------------------------------------------------------------
// Variables de estado del juego
//---------------------------------------------------------------
byte ModoJuego = ModoMemoria; // Por defecto, vamos a jugar al juego de memoria
//---------------------------------------------------------------
byte JuegoMesa[32];// Contiene la combinación de botones a medida que avanzamos
//---------------------------------------------------------------
byte RoundJuego = 0; // Cuenta el número de rondas con las que el jugador ha conseguido
//---------------------------------------------------------------
void setup()
//---------------------------------------------------------------
{
  //---------------------------------------------------------------
  // Configuración de entradas / salidas de hardware. Estos pines se definen en el archivo de encabezado de versiones de hardware
  //---------------------------------------------------------------
  // Habilitar pull ups en entradas
  //---------------------------------------------------------------
  pinMode(BotonRojo, INPUT_PULLUP);
  //---------------------------------------------------------------
  pinMode(BotonVerde, INPUT_PULLUP);
  //---------------------------------------------------------------
  pinMode(BotonAzul, INPUT_PULLUP);
  //---------------------------------------------------------------
  pinMode(BotonAmarillo, INPUT_PULLUP);
  //---------------------------------------------------------------
  pinMode(LedRojo, OUTPUT);
  //---------------------------------------------------------------
  pinMode(LedVerde, OUTPUT);
  //---------------------------------------------------------------
  pinMode(LedAzul, OUTPUT);
  //---------------------------------------------------------------
  pinMode(LedAmarillo, OUTPUT);
  //---------------------------------------------------------------
  pinMode(BUZZER1, OUTPUT);
  //---------------------------------------------------------------
  pinMode(BUZZER2, OUTPUT);
  //---------------------------------------------------------------
  //Comprobación del modo
  //---------------------------------------------------------------
  ModoJuego = ModoMemoria; //Por defecto, vamos a jugar al juego de memoria
  //---------------------------------------------------------------
  // Compruebe si se presiona el botón inferior derecho
  //---------------------------------------------------------------
  if (VerificaBoton() == EleccionAmarillo) TocarCancionBeeGrees();
  //---------------------------------------------------------------
  // Compruebe si se ha pulsado el botón superior derecho
  //---------------------------------------------------------------
  if (VerificaBoton() == EleccionVerde)
    //---------------------------------------------------------------
  {
    //---------------------------------------------------------------
    ModoJuego = ModoBatalla; //Pon el juego en modo batalla
    //---------------------------------------------------------------
    // Enciende el LED superior derecho (verde)
    //---------------------------------------------------------------
    ConjuntoLeds(EleccionVerde);
    //---------------------------------------------------------------
     TonoSonido(EleccionVerde, 150);
    //---------------------------------------------------------------
    ConjuntoLeds(EleccionRojo | EleccionAzul | EleccionAmarillo); // Encienda los otros Leds hasta que suelte el botón
    //---------------------------------------------------------------
    while (VerificaBoton() != NingunaEleccion) ; //Espere a que el usuario deje de pulsar el botón
    //---------------------------------------------------------------
    // Ahora no hagas nada. El modo de batalla será mantenido en la rutina principal
  }
  //---------------------------------------------------------------
  TocarPitidos(); // Una vez finalizada la configuración, saluda al mundo
  //---------------------------------------------------------------
}
//---------------------------------------------------------------
void loop()
//---------------------------------------------------------------
{
  //---------------------------------------------------------------
  ModoParpadeo(); // Parpadea mientras espera que el usuario presione un botón
  //---------------------------------------------------------------
  // Indicar el inicio del juego
  //---------------------------------------------------------------
  ConjuntoLeds(EleccionRojo | EleccionVerde | EleccionAzul | EleccionAmarillo); //Encender todos los Leds
  //---------------------------------------------------------------
  delay(1000);
  //---------------------------------------------------------------
  ConjuntoLeds(EleccionOFF); // Apague los Leds
  //---------------------------------------------------------------
  delay(250);
  //---------------------------------------------------------------
  if (ModoJuego == ModoMemoria)
    //---------------------------------------------------------------
  {
    //---------------------------------------------------------------
    // Juega al juego de memoria y maneja el resultado
    //---------------------------------------------------------------
    if (JugarSimonDice() == true)
      //---------------------------------------------------------------
      TocarPitidos(); //Jugador ganado, jugar tonos ganadores
    //---------------------------------------------------------------
    else
      //---------------------------------------------------------------
      Perdedor(); // Jugador perdido, jugar los tonos perdedores
    //---------------------------------------------------------------
  }
  //---------------------------------------------------------------
  if (ModoJuego == ModoBatalla)
    //---------------------------------------------------------------
  {
    //---------------------------------------------------------------
    JugarBatalla(); //Juegue hasta que alguien pierda
    //---------------------------------------------------------------
    Perdedor(); // Jugador perdido, jugar los tonos perdedores
    //---------------------------------------------------------------
  }
  //---------------------------------------------------------------
}
//---------------------------------------------------------------
// Las siguientes funciones están relacionadas sólo con el juego
// Juega el juego de memoria regular
// Devuelve 0 si el jugador pierde, o 1 si el jugador gana
//---------------------------------------------------------------
boolean JugarSimonDice(void)
//---------------------------------------------------------------
{
  //---------------------------------------------------------------
  randomSeed(millis()); // Sembrar el generador aleatorio con una cantidad aleatoria de millis ()
  //---------------------------------------------------------------
  RoundJuego = 0; // Restablecer el juego al principio
  //---------------------------------------------------------------
  while (RoundJuego < RondasParaGanar)
    //---------------------------------------------------------------
  {
    //---------------------------------------------------------------
    AgregarMovimientos(); // Añadir un botón a los movimientos actuales, luego reproducirlos
    //---------------------------------------------------------------
    JugarMovimientos(); // Reproducir el tablero de juego actual
    //---------------------------------------------------------------
    // Luego, pida al jugador que repita la secuencia.
    //---------------------------------------------------------------
    for (byte  MovimientoActual = 0 ;  MovimientoActual < RoundJuego ;  MovimientoActual++)
      //---------------------------------------------------------------
    {
      //---------------------------------------------------------------
      byte  Eleccion =  EsperarBoton(); // Vea el botón que el usuario presiona
      //---------------------------------------------------------------
      if ( Eleccion == 0) return false; // Si el tiempo de espera excedido, el jugador pierde
      //---------------------------------------------------------------
      if ( Eleccion != JuegoMesa[ MovimientoActual]) return false; // Si la elección es incorrecta, el jugador pierde
      //---------------------------------------------------------------
    }
    //---------------------------------------------------------------
    delay(1000); // Jugador correcto, retraso antes de jugar movimientos
    //---------------------------------------------------------------
  }
  //---------------------------------------------------------------
  return true; // Jugador lo hizo a través de todas las rondas para ganar!
  //---------------------------------------------------------------
}
//---------------------------------------------------------------
// Juega el modo especial de batalla de 2 jugadores
// Un jugador comienza presionando un botón y luego entregándolo al otro jugador
// Este jugador repite el botón y añade uno, luego pasa atrás.
// Esta función devuelve cuando alguien pierde
//---------------------------------------------------------------
boolean JugarBatalla(void)
//---------------------------------------------------------------
{
  //---------------------------------------------------------------
  RoundJuego = 0; //Restablecer el marco de juego de nuevo a un marco
  //---------------------------------------------------------------
  while (1) // Bucle hasta que alguien falla
    //---------------------------------------------------------------
  {
    //---------------------------------------------------------------
    byte NuevoBoton =  EsperarBoton(); // Espere a que el usuario introduzca el siguiente movimiento
    //---------------------------------------------------------------
    JuegoMesa[RoundJuego++] = NuevoBoton; // Añadir este nuevo botón a la matriz de juego
    //---------------------------------------------------------------
    // Luego, pida al jugador que repita la secuencia.
    //---------------------------------------------------------------
    for (byte  MovimientoActual = 0 ;  MovimientoActual < RoundJuego ;  MovimientoActual++)
      //---------------------------------------------------------------
    {
      //---------------------------------------------------------------
      byte  Eleccion =  EsperarBoton();
      //---------------------------------------------------------------
      if ( Eleccion == 0) return false; // Si el tiempo de espera expiró, el jugador pierde.
      //---------------------------------------------------------------
      if ( Eleccion != JuegoMesa[ MovimientoActual]) return false; // Si la elección es incorrecta, el jugador pierde.
      //---------------------------------------------------------------
    }
    //---------------------------------------------------------------
    delay(100); // Dar al usuario un extra de 100ms para entregar el juego al otro jugador
    //---------------------------------------------------------------
  }
  //---------------------------------------------------------------
  return true; // Nunca deberíamos llegar aquí
  //---------------------------------------------------------------
}
//---------------------------------------------------------------
// Reproduce el contenido actual de los movimientos del juego
//---------------------------------------------------------------
void JugarMovimientos(void)
//---------------------------------------------------------------
{
  //---------------------------------------------------------------
  for (byte  MovimientoActual = 0 ;  MovimientoActual < RoundJuego ;  MovimientoActual++)
    //---------------------------------------------------------------
  {
    //---------------------------------------------------------------
     TonoSonido(JuegoMesa[ MovimientoActual], 150);
    //---------------------------------------------------------------
    // Espera un poco de tiempo entre la reproducción del botón
    // Acortar esto para que el juego sea más difícil
    //---------------------------------------------------------------
    delay(150); // 150 funciona bien. 75 se pone rápido.
    //---------------------------------------------------------------
  }
  //---------------------------------------------------------------
}
//---------------------------------------------------------------
// Agrega un nuevo botón aleatorio a la secuencia del juego, muestreando el temporizador
//---------------------------------------------------------------
void AgregarMovimientos(void)
//---------------------------------------------------------------
{
  //---------------------------------------------------------------
  byte NuevoBoton = random(0, 4); // Min (incluido), máx (excluido)
  //---------------------------------------------------------------
  // Tenemos que convertir este número, 0 a 3, a  Eleccions
  //---------------------------------------------------------------
  if (NuevoBoton == 0) NuevoBoton = EleccionRojo;
  //---------------------------------------------------------------
  else if (NuevoBoton == 1) NuevoBoton = EleccionVerde;
  //---------------------------------------------------------------
  else if (NuevoBoton == 2) NuevoBoton = EleccionAzul;
  //---------------------------------------------------------------
  else if (NuevoBoton == 3) NuevoBoton = EleccionAmarillo;
  //---------------------------------------------------------------
  JuegoMesa[RoundJuego++] = NuevoBoton; // Añadir este nuevo botón a la matriz de juego
  //---------------------------------------------------------------
}
//---------------------------------------------------------------
// Las siguientes funciones controlan el hardware
// Enciende un LED determinado
// Pasa un byte que se compone de EleccionRojo, EleccionAmarillo, etc
//---------------------------------------------------------------
void ConjuntoLeds(byte Leds)
//---------------------------------------------------------------
{
  //---------------------------------------------------------------
  if ((Leds & EleccionRojo) != 0)
    //---------------------------------------------------------------
    digitalWrite(LedRojo, HIGH);
  //---------------------------------------------------------------
  else
    //---------------------------------------------------------------
    digitalWrite(LedRojo, LOW);
  //---------------------------------------------------------------

  //---------------------------------------------------------------
  if ((Leds & EleccionVerde) != 0)
    //---------------------------------------------------------------
    digitalWrite(LedVerde, HIGH);
  //---------------------------------------------------------------
  else
    //---------------------------------------------------------------
    digitalWrite(LedVerde, LOW);
  //---------------------------------------------------------------

  //---------------------------------------------------------------
  if ((Leds & EleccionAzul) != 0)
    //---------------------------------------------------------------
    digitalWrite(LedAzul, HIGH);
  //---------------------------------------------------------------
  else
    //---------------------------------------------------------------
    digitalWrite(LedAzul, LOW);
  //---------------------------------------------------------------

  //---------------------------------------------------------------
  if ((Leds & EleccionAmarillo) != 0)
    //---------------------------------------------------------------
    digitalWrite(LedAmarillo, HIGH);
  //---------------------------------------------------------------
  else
    //---------------------------------------------------------------
    digitalWrite(LedAmarillo, LOW);
  //---------------------------------------------------------------
}
//---------------------------------------------------------------
// Esperar a que se presione un botón.
// Devuelve uno de los colores del LED (LedRojo, etc.) si tiene éxito, 0 si se ha agotado el tiempo
//---------------------------------------------------------------
byte  EsperarBoton(void)
//---------------------------------------------------------------
{
  //---------------------------------------------------------------
  long TiempoInicio = millis(); // Recuerde el momento en que iniciamos el ciclo
  //---------------------------------------------------------------

  //---------------------------------------------------------------
  while ( (millis() - TiempoInicio) < LimiteTiempo) // Bucle hasta que haya pasado demasiado tiempo
    //---------------------------------------------------------------
  {
    //---------------------------------------------------------------
    byte Boton = VerificaBoton();
    //---------------------------------------------------------------

    //---------------------------------------------------------------
    if (Boton != NingunaEleccion)
      //---------------------------------------------------------------
    {
      //---------------------------------------------------------------
       TonoSonido(Boton, 150); // Reproduzca el botón que acaba de pulsar el usuario
      //---------------------------------------------------------------

      //---------------------------------------------------------------
      while (VerificaBoton() != NingunaEleccion) ; // Ahora vamos a esperar a que el usuario suelte el botón
      //---------------------------------------------------------------
      delay(10); // Esto ayuda con el rebote y los golpes dobles accidentales
      //---------------------------------------------------------------

      //---------------------------------------------------------------
      return Boton;
      //---------------------------------------------------------------
    }
    //---------------------------------------------------------------
  }
  //---------------------------------------------------------------
  return NingunaEleccion; // Si llegamos aquí, ¡nos hemos agotado!
  //---------------------------------------------------------------
}
//---------------------------------------------------------------
// Devuelve un bit '1' en la posición correspondiente a EleccionRojo, EleccionVerde, etc.
//---------------------------------------------------------------
byte VerificaBoton(void)
//---------------------------------------------------------------
{
  //---------------------------------------------------------------
  if (digitalRead(BotonRojo) == 0) return (EleccionRojo);
  //---------------------------------------------------------------
  else if (digitalRead(BotonVerde) == 0) return (EleccionVerde);
  //---------------------------------------------------------------
  else if (digitalRead(BotonAzul) == 0) return (EleccionAzul);
  //---------------------------------------------------------------
  else if (digitalRead(BotonAmarillo) == 0) return (EleccionAmarillo);
  //---------------------------------------------------------------
  return (NingunaEleccion); // Si no se pulsa ningún botón, devolver ninguno
  //---------------------------------------------------------------
}
//---------------------------------------------------------------
// Enciende un LED y el tono de reproducción
// Rojo, superior izquierda: 440Hz - 2.272ms - 1.136ms pulso
// Verde, superior derecha: 880Hz - 1.136ms - 0.568ms pulso
// Azul, abajo a la izquierda: 587.33Hz - 1.702ms - 0.851ms pulso
// Amarillo, abajo a la derecha: 784Hz - 1.276ms - 0.638ms pulso
//---------------------------------------------------------------
void  TonoSonido(byte Cual, int LongitudZumbido)
//---------------------------------------------------------------
{
  //---------------------------------------------------------------
  ConjuntoLeds(Cual); // Activar un LED determinado
  //---------------------------------------------------------------
  // Reproduce el sonido asociado con el LED
  //---------------------------------------------------------------
  switch (Cual)
    //---------------------------------------------------------------
  {
    //---------------------------------------------------------------
    case EleccionRojo:
      //---------------------------------------------------------------
      SonidoBuzzer(LongitudZumbido, 1136);
      //---------------------------------------------------------------
      break;
    //---------------------------------------------------------------
    case EleccionVerde:
      //---------------------------------------------------------------
      SonidoBuzzer(LongitudZumbido, 568);
      //---------------------------------------------------------------
      break;
    //---------------------------------------------------------------
    case EleccionAzul:
      //---------------------------------------------------------------
      SonidoBuzzer(LongitudZumbido, 851);
      //---------------------------------------------------------------
      break;
    //---------------------------------------------------------------
    case EleccionAmarillo:
      //---------------------------------------------------------------
      SonidoBuzzer(LongitudZumbido, 638);
      //---------------------------------------------------------------
      break;
      //---------------------------------------------------------------
  }
  //---------------------------------------------------------------
  ConjuntoLeds(EleccionOFF); //Apague todos los Leds
  //---------------------------------------------------------------
}
//---------------------------------------------------------------
// Cambia el buzzer cada DemoraZumbido, para una duración de LongitudZumbido.
//---------------------------------------------------------------
void SonidoBuzzer(int LongitudZumbido, int DemoraZumbido)
//---------------------------------------------------------------
{
  //---------------------------------------------------------------
  // Convertir el tiempo total de reproducción de milisegundos a microsegundos
  //---------------------------------------------------------------
  long LongitudZumbidoMicroSegundo = LongitudZumbido * (long)1000;
  //---------------------------------------------------------------
  // Loop hasta que el tiempo de reproducción restante sea menor que un solo DemoraZumbido
  //---------------------------------------------------------------
  while (LongitudZumbidoMicroSegundo > (DemoraZumbido * 2))
    //---------------------------------------------------------------
  {
    //---------------------------------------------------------------
    LongitudZumbidoMicroSegundo -= DemoraZumbido * 2; // Disminuir el tiempo de reproducción restante
    //---------------------------------------------------------------
    // Conmutar el zumbador a varias velocidades
    //---------------------------------------------------------------
    digitalWrite(BUZZER1, LOW);
    //---------------------------------------------------------------
    digitalWrite(BUZZER2, HIGH);
    //---------------------------------------------------------------
    delayMicroseconds(DemoraZumbido);
    //---------------------------------------------------------------
    digitalWrite(BUZZER1, HIGH);
    //---------------------------------------------------------------
    digitalWrite(BUZZER2, LOW);
    //---------------------------------------------------------------
    delayMicroseconds(DemoraZumbido);
    //---------------------------------------------------------------
  }
  //---------------------------------------------------------------
}
//---------------------------------------------------------------
// Reproducir el sonido ganador y las luces
//---------------------------------------------------------------
void TocarPitidos(void)
//---------------------------------------------------------------
{
  //---------------------------------------------------------------
  ConjuntoLeds(EleccionVerde | EleccionAzul);
  //---------------------------------------------------------------
  SonidoGanador();
  //---------------------------------------------------------------
  ConjuntoLeds(EleccionRojo | EleccionAmarillo);
  //---------------------------------------------------------------
  SonidoGanador();
  //---------------------------------------------------------------
  ConjuntoLeds(EleccionVerde | EleccionAzul);
  //---------------------------------------------------------------
  SonidoGanador();
  //---------------------------------------------------------------
  ConjuntoLeds(EleccionRojo | EleccionAmarillo);
  //---------------------------------------------------------------
  //---------------------------------------------------------------
  SonidoGanador();
  //---------------------------------------------------------------
}
//---------------------------------------------------------------
// Reproducir el sonido ganador
// Esto es solo un sonido (molesto) único que surgió, no hay magia
//---------------------------------------------------------------
void SonidoGanador(void)
//---------------------------------------------------------------
{
  //---------------------------------------------------------------
  // Conmutar el zumbador a varias velocidades
  //---------------------------------------------------------------
  for (byte x = 250 ; x > 70 ; x--)
    //---------------------------------------------------------------
  {
    //---------------------------------------------------------------
    for (byte y = 0 ; y < 3 ; y++)
      //---------------------------------------------------------------
    {
      //---------------------------------------------------------------
      digitalWrite(BUZZER2, HIGH);
      //---------------------------------------------------------------
      digitalWrite(BUZZER1, LOW);
      //---------------------------------------------------------------
      delayMicroseconds(x);
      //---------------------------------------------------------------
      digitalWrite(BUZZER2, LOW);
      //---------------------------------------------------------------
      digitalWrite(BUZZER1, HIGH);
      //---------------------------------------------------------------
      delayMicroseconds(x);
      //---------------------------------------------------------------
    }
    //---------------------------------------------------------------
  }
  //---------------------------------------------------------------
}
//---------------------------------------------------------------
// Reproducir el sonido perdedor / luces
//---------------------------------------------------------------
void Perdedor(void)
//---------------------------------------------------------------
{
  //---------------------------------------------------------------
  ConjuntoLeds(EleccionRojo | EleccionVerde);
  //---------------------------------------------------------------
  SonidoBuzzer(255, 1500);
  //---------------------------------------------------------------
  ConjuntoLeds(EleccionAzul | EleccionAmarillo);
  //---------------------------------------------------------------
  SonidoBuzzer(255, 1500);
  //---------------------------------------------------------------
  ConjuntoLeds(EleccionRojo | EleccionVerde);
  //---------------------------------------------------------------
  SonidoBuzzer(255, 1500);
  //---------------------------------------------------------------
  ConjuntoLeds(EleccionAzul | EleccionAmarillo);
  //---------------------------------------------------------------
  SonidoBuzzer(255, 1500);
  //---------------------------------------------------------------
}
//---------------------------------------------------------------
// Mostrar una pantalla de "modo de atracción" mientras espera que el usuario presione el botón.
//---------------------------------------------------------------
void ModoParpadeo(void)
//---------------------------------------------------------------
{
  //---------------------------------------------------------------
  while (1)
    //---------------------------------------------------------------
  {
    //---------------------------------------------------------------
    ConjuntoLeds(EleccionRojo);
    //---------------------------------------------------------------
    delay(100);
    //---------------------------------------------------------------
    if (VerificaBoton() != NingunaEleccion) return;
    //---------------------------------------------------------------
    ConjuntoLeds(EleccionAzul);
    //---------------------------------------------------------------
    delay(100);
    //---------------------------------------------------------------
    if (VerificaBoton() != NingunaEleccion) return;
    //---------------------------------------------------------------
    ConjuntoLeds(EleccionVerde);
    //---------------------------------------------------------------
    delay(100);
    //---------------------------------------------------------------
    if (VerificaBoton() != NingunaEleccion) return;
    //---------------------------------------------------------------
    ConjuntoLeds(EleccionAmarillo);
    //---------------------------------------------------------------
    delay(100);
    //---------------------------------------------------------------
    if (VerificaBoton() != NingunaEleccion) return;
    //---------------------------------------------------------------
  }
  //---------------------------------------------------------------
}
//---------------------------------------------------------------
// Las siguientes funciones están relacionadas con Beegees Easter Egg only
// Notas en la melodía. Cada nota es sobre una nota 1/8, "0" s son descansos.
//---------------------------------------------------------------
int Melodia[] = {
  //---------------------------------------------------------------
  Nota_G4, Nota_A4, 0, Nota_C5, 0, 0, Nota_G4, 0, 0, 0,
  //---------------------------------------------------------------
  Nota_E4, 0, Nota_D4, Nota_E4, Nota_G4, 0,
  //---------------------------------------------------------------
  Nota_D4, Nota_E4, 0, Nota_G4, 0, 0,
  //---------------------------------------------------------------
  Nota_D4, 0, Nota_E4, 0, Nota_G4, 0, Nota_A4, 0, Nota_C5, 0
  //---------------------------------------------------------------
};
//---------------------------------------------------------------
int DuracionNota = 115; // Esto básicamente establece el tempo, 115 es casi correcto para un disco groove :)
//---------------------------------------------------------------
int LedNumero = 0; // Mantiene la pista de qué LED estamos encendidos durante el loop beegees
//---------------------------------------------------------------
// No hagas nada más que tocar bad beegees music
// Esta función se activa cuando el usuario mantiene pulsado el botón inferior derecho durante el encendido
//---------------------------------------------------------------
void TocarCancionBeeGrees()
//---------------------------------------------------------------
{
  //---------------------------------------------------------------
  // Enciende el LED derecho inferior (amarillo)
  //---------------------------------------------------------------
  ConjuntoLeds(EleccionAmarillo);
  //---------------------------------------------------------------
   TonoSonido(EleccionAmarillo, 150);
  //---------------------------------------------------------------
  ConjuntoLeds(EleccionRojo | EleccionVerde | EleccionAzul); // Encienda los otros Leds hasta que suelte el botón
  //---------------------------------------------------------------
  while (VerificaBoton() != NingunaEleccion) ; //Espere a que el usuario deje de pulsar el botón
  //---------------------------------------------------------------
  ConjuntoLeds(NingunaEleccion); //Apague los Leds
  //---------------------------------------------------------------
  delay(1000); // Espere un segundo antes de tocar la canción
  //---------------------------------------------------------------
  digitalWrite(BUZZER1, LOW); // Configure el lado "BUZZER1" del zumbador para que permanezca bajo, mientras tocamos el tono en el otro pino.
  //---------------------------------------------------------------
  while (VerificaBoton() == NingunaEleccion) // Reproducir canción hasta que pulse un botón
    //---------------------------------------------------------------
  {
    //---------------------------------------------------------------
    // itera sobre las notas de la melodía:
    //---------------------------------------------------------------
    for (int EstaNota = 0; EstaNota < 32; EstaNota++) {
      //---------------------------------------------------------------
      CambioLed();
      //---------------------------------------------------------------
      tone(BUZZER2, Melodia[EstaNota], DuracionNota);
      //---------------------------------------------------------------
      // para distinguir las notas, establezca un tiempo mínimo entre ellas.
      //---------------------------------------------------------------
      // la duración de la nota + 30% parece funcionar bien:
      //---------------------------------------------------------------
      int PausaEntreNotas = DuracionNota * 1.30;
      //---------------------------------------------------------------
      delay(PausaEntreNotas);
      //---------------------------------------------------------------
      // detener la reproducción de tono:
      //---------------------------------------------------------------
      noTone(BUZZER2);
      //---------------------------------------------------------------
    }
    //---------------------------------------------------------------
  }
  //---------------------------------------------------------------
}
//---------------------------------------------------------------
// Cada vez que se llama a esta función, la tabla se mueve al siguiente LED
//---------------------------------------------------------------
void CambioLed(void)
//---------------------------------------------------------------
{
  //---------------------------------------------------------------
  ConjuntoLeds(1 << LedNumero); // Cambiar el LED
  //---------------------------------------------------------------
  LedNumero++; // Ir al siguiente LED
  //---------------------------------------------------------------
  if (LedNumero > 3) LedNumero = 0; // Envuelva el contador si es necesario
  //---------------------------------------------------------------
}
//---------------------------------------------------------------