Simon Dice: Permainan Mengingat Urutan LED dengan Arduino

Skema & Diagram Sirkuit

Skema Rangkaian Simon Dice

Rangkaian menggunakan Arduino UNO sebagai pengendali utama. Empat LED digunakan sebagai indikator warna, empat push button digunakan untuk memasukkan jawaban, satu push button tambahan digunakan untuk memulai permainan, dan satu passive buzzer menghasilkan nada. Diagram rangkaian asli tersedia pada dokumentasi Hackster.io.

1. Koneksi Empat LED

• LED hijau: anoda melalui resistor 220 ohm ke pin digital 5, katoda ke GND.
• LED kuning: anoda melalui resistor 220 ohm ke pin digital 4, katoda ke GND.
• LED biru: anoda melalui resistor 220 ohm ke pin digital 3, katoda ke GND.
• LED merah: anoda melalui resistor 220 ohm ke pin digital 2, katoda ke GND.

2. Koneksi Empat Push Button

• Tombol hijau: pin digital 6.
• Tombol kuning: pin digital 7.
• Tombol biru: pin digital 8.
• Tombol merah: pin digital 9.
• Setiap tombol menggunakan resistor 10k ohm sebagai pull-up resistor eksternal.
• Gunakan konfigurasi aktif LOW: input terbaca LOW ketika tombol ditekan dan HIGH ketika tombol dilepas.

3. Koneksi Tombol Mulai

• Satu terminal tombol mulai dihubungkan ke pin digital 10.
• Terminal lainnya dihubungkan ke GND.
• Gunakan satu resistor 10k ohm sebagai pull-up resistor.

4. Koneksi Passive Buzzer

• Pin positif atau terminal sinyal buzzer dihubungkan ke pin digital 11 melalui resistor 100 ohm sesuai rangkaian.
• Terminal negatif buzzer dihubungkan ke GND.

5. Catu Daya dan Ground

Arduino UNO mendapatkan daya melalui USB atau sumber daya yang sesuai dengan spesifikasi board. Semua komponen harus memiliki jalur GND bersama. Pastikan resistor pembatas arus terpasang dengan benar dan periksa polaritas LED serta buzzer sebelum menyalakan rangkaian.

Diagram wiring asli proyek Simon Dice dari Hackster.io, file gga_simondice_bb_fMDKhtZ8Gt.jpg.

6. Pemetaan Pin Arduino

• Pin 2: LED merah.
• Pin 3: LED biru.
• Pin 4: LED kuning.
• Pin 5: LED hijau.
• Pin 6: tombol hijau.
• Pin 7: tombol kuning.
• Pin 8: tombol biru.
• Pin 9: tombol merah.
• Pin 10: tombol mulai.
• Pin 11: passive buzzer.

Perhatikan bahwa diagram dan program asli menggunakan konfigurasi pull-up eksternal. Jika menggunakan INPUT_PULLUP, sesuaikan wiring tombol agar setiap tombol menghubungkan pin input ke GND ketika ditekan dan jangan memasang resistor pull-up eksternal yang tidak diperlukan.

Kode Program

/* Este sketch en una version del juego \"Simon Dice\"
  Existe un boton 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 se acierta 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 mas y se incrementa la velocidad
  en que se muestra la secuencia para hacer mas dificil el juego.

  Si se falla los cuatro LEDs parpadearan 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 montaran como resistencias PullUp)
  1 zumbador pasivo (passive buzzer)
  1 resistencia de 100ohm (para el zumbador)
  Cables para conexion 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;
const int VELOCIDAD_INICIAL = 1000;

byte ronda = 0;
byte secuencia[MAX_RONDAS + 1];
int velocidad = VELOCIDAD_INICIAL;

// Definimos notas musicales, duraciones y variable tempo
#define NOTA_B3 246.94
#define NOTA_C4 261.63
#define NOTA_C4S 277.18
#define NOTA_D4 293.66
#define NOTA_E4 329.63
#define NOTA_F4 349.23

#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;

// Variables para el control de rebotes de los pulsadores
long rebote_ultima_senal_verde = 0;
long rebote_ultima_senal_amarillo = 0;
long rebote_ultima_senal_azul = 0;
long rebote_ultima_senal_rojo = 0;
long rebote_retardo = 50;

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 en modo salida
  pinMode(PIN_ZUMBADOR, OUTPUT);

  // Inicializamos las salidas 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 mediante resistencias pull-up
  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) {
    espera_pulsacion_inicio();
  }

  if (ronda == 1) {
    flash_bienvenida();
  }

  genera_secuencia();
  lee_respuesta();
}

void espera_pulsacion_inicio() {
  // Esperamos hasta que pulsen el boton de inicio
  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 o frecuencias
    duracion = factor multiplicador del tempo para cada nota
    tempo = duracion de un pulso en milisegundos
    nro_notas = numero de notas del array
  */
  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);
  delay(tiempo);
}

void tema_inicio() {
  // Melodia 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};
  reproduce_melodia(notas, duracion, 100, 6);
}

void tema_game_over() {
  // Melodia 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() {
  // 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);
    }
  }

  // Suena la melodia de inicio
  tema_inicio();
  delay(1000);
}

void flash_respuesta_correcta() {
  // Esperamos un segundo para continuar
  delay(1000);
}

void flash_respuesta_incorrecta() {
  // Suena la melodia Game Over con los cuatro 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 siguiente elemento de la secuencia
  randomSeed(analogRead(0));
  secuencia[ronda] = random(2, 5);

  for (int x = 1; x <= ronda; x++) {
    digitalWrite(secuencia[x], HIGH);
    reproduce_nota_led(secuencia[x], velocidad);
    digitalWrite(secuencia[x], LOW);
    delay(100 * velocidad / VELOCIDAD_INICIAL);
  }
}

void lee_respuesta() {
  // Leemos las pulsaciones y comprobamos la secuencia
  boolean correcto = true;
  byte x = 1;
  byte pulsacion = 0;

  while (correcto and x <= ronda) {
    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)) {

      // Comprobamos si la pulsacion coincide con la secuencia
      if (pulsacion != secuencia[x]) {
        correcto = false;
      }
      else {
        x++;
        pulsacion = 0;
      }
    }
  }

  if (correcto == true) {
    delay(500);
    flash_respuesta_correcta();
    ronda++;

    if (velocidad >= 50) {
      velocidad = velocidad - 50;
    }
  }
  else {
    flash_respuesta_incorrecta();
    ronda = 0;
    velocidad = VELOCIDAD_INICIAL;
    espera_pulsacion_inicio();
  }
}