Aprender

Un juego de Simón dice con cuatro LED y cuatro botones

Avanzado

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
ESP32-C3: Simón diceen vivo0.000 s 0.00x
Presiona Ejecutar, observa la lámpara y luego presiona el botón que está debajo
El ejemplo de Simón: cuatro lámparas en GPIO 2 a 5, cuatro botones en GPIO 18 a 21. Observa la lámpara y luego presiona el botón que está debajo.

Simon is the memory game from the 1970s: the machine flashes a color, you press it back, it flashes that color and one more, and so on until you slip. It is one of the best first game projects because it uses only LEDs and buttons, and the code teaches arrays, loops and state in under a hundred lines.

El circuito de arriba lo ejecuta. Presiona Ejecutar, fíjate qué lámpara se enciende (es la amarilla) y presiona el botón que está debajo. El juego agrega un paso cada ronda, hasta dieciséis. Si te equivocas, las cuatro lámparas destellan tres veces y comienza un juego nuevo. El monitor serie dice hasta dónde llegaste.

La placa aquí es una ESP32-C3, pero el sketch es código Arduino puro: digitalWrite, digitalRead, delay y random. Cambia los ocho números de pin y funciona en un Uno o un Nano sin ningún otro cambio.

Lo que necesitas

  • Una placa ESP32-C3, o una Arduino Uno o Nano
  • Cuatro LED: rojo, amarillo, verde y azul
  • Cuatro resistencias de 220 ohm
  • Cuatro botones momentáneos
  • Una protoboard y cables jumper

Cableado

Componente y pinVa aNota
LED rojo, con 220 ohmGPIO 2Cátodo del LED a GND
LED amarillo, con 220 ohmGPIO 3
LED verde, con 220 ohmGPIO 4
LED azul, a través de 220 ohmsGPIO 5
Botón bajo el rojoGPIO 18La otra pata a GND, con pull-up interno
Botón bajo el amarilloGPIO 19
Botón bajo el verdeGPIO 20
Botón bajo el azulGPIO 21

Cómo funciona el juego

Al inicio, el sketch llena un arreglo de dieciséis pasos con números aleatorios del 0 al 3, uno por lámpara. Una variable llamada length indica cuántos están en juego, y empieza en 1. Al comienzo de cada ronda, el sketch destella los pasos del 0 al length menos 1, cada lámpara encendida 350 ms con una pausa de 175 ms, y luego espera a que el jugador los presione de vuelta en el mismo orden.

Leer los botones es un ciclo sencillo. pressedButton() revisa los cuatro pines y devuelve el primero que lea LOW, o -1 si ninguno lo hace. El juego espera hasta obtener algo, enciende esa lámpara mientras el botón está presionado y la compara con el paso que espera. Si coincide, avanza al siguiente paso; si no, el juego termina.

Cuando toda la ronda es correcta, el monitor serie imprime "round 1 correct" (o 2, o 3), length sube en uno y comienza la siguiente ronda. A los dieciséis, el arreglo se agota, las lámparas destellan cinco veces y comienza un juego nuevo. No hay temporizador, así que el jugador puede tomarse el tiempo que quiera en cada paso. Agregar uno es lo primero que cambia la mayoría de la gente.

El sketch

Las lámparas y los botones están en dos arreglos, así que el mismo índice significa el mismo color en todas partes. El botón i siempre responde a la lámpara i, y eso es lo que mantiene el código corto.

Fíjate que random() nunca recibe una semilla. En una placa sin reloj eso significa que la secuencia es la misma cada vez que se enciende: en el circuito de arriba siempre empieza amarillo, amarillo, amarillo. Eso es útil mientras pruebas. Para un juego de verdad, agrega randomSeed(analogRead(A0)) en un Uno con A0 sin conectar, o genera la semilla desde micros() en el momento de la primera pulsación, algo que nadie puede predecir.

El sketch de Simón (la versión completa está en el editor)
const int LEDS[] = {2, 3, 4, 5};
const int BUTTONS[] = {18, 19, 20, 21};
const int COUNT = 4;
const int MAX_LEN = 16;

uint8_t sequence[MAX_LEN];
int length = 1;

static void flash(int i, int ms) {
  digitalWrite(LEDS[i], HIGH);
  delay(ms);
  digitalWrite(LEDS[i], LOW);
  delay(ms / 2);
}

static int pressedButton() {
  for (int i = 0; i < COUNT; i++) {
    if (digitalRead(BUTTONS[i]) == LOW) return i;
  }
  return -1;
}

void loop() {
  for (int i = 0; i < length; i++) flash(sequence[i], 350);
  delay(200);

  for (int i = 0; i < length; i++) {
    int got = -1;
    while ((got = pressedButton()) < 0) delay(1);  // delay(1) lets the watchdog see the chip is alive
    digitalWrite(LEDS[got], HIGH);
    if (got != sequence[i]) {
      digitalWrite(LEDS[got], LOW);
      Serial.print("wrong at step ");
      Serial.print(i + 1);
      Serial.print(" of ");
      Serial.println(length);
      allFlash(3, 120);
      waitForRelease();
      newGame();
      return;
    }
    waitForRelease();
    digitalWrite(LEDS[got], LOW);
  }

  Serial.print("round ");
  Serial.print(length);
  Serial.println(" correct");
  length++;
  delay(500);
}

Hazlo tuyo

Agrega sonido. Un zumbador pasivo en un pin libre y tone(pin, freq, 300) dentro de flash() le da a cada color su propia nota. Elige cuatro que suenen bien juntas, como 330, 392, 494 y 659 Hz.

Agrega un límite de tiempo. Guarda millis() cuando la ronda empieza a esperar y termina el juego si ningún botón llega en dos segundos. Eso convierte el ciclo de lectura en el patrón de "hacer dos cosas a la vez" que todo proyecto más grande necesita.

Hazlo más rápido conforme crece. Pasa un tiempo más corto a flash() a medida que sube length, por ejemplo 350 menos 15 por la ronda, con un mínimo de 150.

Guarda un récord. Almacena la mejor ronda en una variable e imprímela cuando termine un juego. En un Uno, EEPROM.put() la conserva aunque se corte la energía.

Errores comunes

Un botón que siempre lee como presionado. Cada botón va de su pin a GND, y el pin necesita INPUT_PULLUP. Con INPUT simple y sin resistencia, el pin queda flotando y el juego ve pulsaciones que nunca ocurrieron.

Cada pulsación cuenta dos veces. Sin waitForRelease(), el ciclo ve la misma pulsación en el paso siguiente y la toma como la respuesta siguiente. El sketch espera a que todos los botones se suelten y luego 20 ms más para que los contactos se estabilicen.

Botones conectados del mismo lado del canal central de la protoboard. Un botón de cuatro patas une sus patas en pares; colócalo a través del canal central y usa patas de lados opuestos, o siempre estará cerrado.

LED sin resistencia. Una resistencia de 220 ohm por LED mantiene la corriente en unos 6 mA en una placa de 3.3 V y unos 14 mA en una de 5 V.

En una placa ESP32-C3 real, revisa qué pines están libres. GPIO 18 y 19 son los pines USB del propio chip, así que en placas que usan USB nativo para programar, los botones ahí pueden cortar la conexión serie. Mover los botones a otros GPIO libres y cambiar el arreglo BUTTONS lo soluciona.

Abre este circuito en el editor. ESP32-C3: Simón dice, cableado tal como se ejecuta en la parte superior de esta página. Cambia un componente o un valor y ejecútalo de nuevo.

Abrir el circuito

Preguntas

¿Cómo hago un juego de Simón dice con Arduino?

Conecta cuatro LED mediante resistencias de 220 ohm a cuatro pines, y cuatro botones desde otros cuatro pines a GND. Llena un arreglo con números aleatorios del 0 al 3, destella los primeros N, luego lee los botones y compara. Si el jugador acierta los N, agrega uno y repite.

¿Por qué mi juego de Simón repite la misma secuencia cada vez?

Porque random() nunca recibió una semilla. Llama a randomSeed() una vez en setup con algo impredecible, como analogRead en un pin sin conectar, o el valor de micros() cuando el jugador presiona un botón por primera vez.

¿Puedo armar Simón en Tinkercad?

Tinkercad Circuits tiene LED, botones y el Uno, así que sí. En Mokxi puedes abrir y ejecutar la versión de arriba sin cuenta, y cambiarla a un Uno modificando los números de pin.

¿Necesito un zumbador?

No. El juego funciona solo con luces. Un zumbador pasivo y tone() agregan una nota por color, lo que hace mucho más fácil recordar secuencias largas.

Ármalo en la vida real

Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.