Grupo 12: Naroa Martín Simón, Icíar Moreno López y Adrián Muñoz Serrano

1. INFORMACIÓN GENERAL

1.1. Nombre del proyecto

Piano interactivo.

1.2. Descripción

El proyecto ha consistido en diseñar y fabricar un sistema empotrado basado en la plataforma de hardware libre Arduino.

El sistema es capaz de procesar la información en tiempo real y ofrece cinco experiencias distintas:

• Modo Libre: Funciona como un teclado estándar donde cada botón corresponde a una nota de la escala musical (Do, Re, Mi, Fa, Sol, La y Si). El usuario puede tocar melodías sencillas.
• Modo Simón Dice: El sistema funciona como un juego de memoria de repetir secuencias de luces y sonidos. El usuario debe repetir, pulsando los botones, la secuencia exacta que se muestre en los LEDs.
• Modo Piano Tiles: El piano tiene un modo de agilidad. El microcontrolador selecciona uno de los LEDs de forma aleatoria y al iluminarse le indica al usuario qué botón debe pulsar.
• Modo Reproducción Automática: El sistema actúa como un reproductor autónomo. El usuario selecciona la canción pulsando la tecla correspondiente (hay 7 canciones, una por tecla) y se ejecuta, coordinando el sonido con los leds.
• Modo Aprendizaje Guiado: Diseñado para aprender canciones. El sistema ilumina el LED de la nota que debe ser tocada y detiene la canción hasta que el usuario pulsa la tecla correcta.

1.3. Objetivo

Desarrollar un piano interactivo que combine cuatro subsistemas de hardware:

• Audio (Buzzer): Generación de las frecuencias sonoras que corresponden a las notas musicales.
• Interfaz de texto (LCD): Integración de una pantalla LCD para comunicar estados y modos al usuario.
• Retroalimentación visual (LEDs): Implementación de una hilera de LEDs que sirven como guía visual y elementos interactivos.
• Entrada analógica (Botones): Se usan pulsadores para las teclas del piano y para cambiar el modo de juego.

2. IMPLEMENTACIÓN

El sistema se divide en tres bloques principales que interactúan entre sí:

1. Sistema de entrada (Escalera de botones y botón de modo):

En lugar de usar siete pines para siete botones, hemos diseñado una escalera de resistencias de 1 kΩ, de esta manera, todos los botones están conectados a un único pin analógico (A0). Cada botón, al ser pulsado, cierra el circuito pasando por un número distinto de resistencias, lo que genera un voltaje específico para cada nota. Al pulsar el primer botón (Do) la corriente no atraviesa ninguna resistencia, por lo que al pin A0 llega un alto voltaje, en cambio, si pulsas el último (Si), la corriente tiene que atravesar todas las resistencias y llega con un voltaje más bajo. Después, el Arduino traduce ese voltaje a un número y así el código puede distinguir las distintas notas.

Por otra parte, la conexión del botón de modo se realiza vinculando un terminal del pulsador directamente a la línea de 5V, mientras que el terminal opuesto se conecta a una resistencia de 10 kΩ derivada a tierra y al pin D7 del Arduino. Gracias a la resistencia a tierra, el pin permanece en estado LOW de forma constante, sin embargo, al presionar el botón, el circuito se cierra y permite que el voltaje fluya hacia el pin, cambiando su estado a HIGH y activando la transición lógica entre los diferentes modos de juego.

2. Sistema de procesamiento (Código y lógica):

La lógica se basa en la interpretación de señales de entrada para activar salidas específicas (frecuencia sonora, señales lumínicas e información textual).

El sistema de audio utiliza un buzzer para transformar señales eléctricas en ondas sonoras. Para que el piano suene afinado, el microcontrolador hace que el buzzer vibre a una velocidad específica para cada nota. Cuando el usuario pulsa un botón y el Arduino detecta el voltaje correspondiente en el pin A0, el programa consulta un array que contiene las frecuencias de las notas. Después, ejecuta la función tone(), que envía una señal eléctrica al buzzer, por ejemplo, al tocar la nota Do, el buzzer vibra exactamente 262 veces por segundo.

Por otra parte, el sistema utiliza 7 LEDs (uno para cada nota) que actúan como retroalimentación en tiempo real y como elementos interactivos. Cada LED está conectado a un pin digital del Arduino (del D8 al D10 y de A1 al A4). La pata corta (cátodo) de cada LED se conecta a tierra con una resistencia de 300 Ω, mientras que la pata larga (ánodo) recibe los 5V del pin correspondiente.

En cuanto a la pantalla LCD, su conexión principal utiliza seis pines digitales del Arduino (D12, D11, D5, D4, D3 y D2) para gestionar las líneas de control y los datos. Además, el panel requiere alimentación de 5V Y GND para el circuito interno y la iluminación. Los terminales V0 y LED se conectan a resistencias para ajustar la nitidez de los caracteres y proteger el diodo interno de iluminación.

Además, el piano tiene cinco modos de uso:

• Modo Libre: El código mide el voltaje en A0, identifica la nota que está siendo pulsada y activa simultáneamente el altavoz y el LED. Cuando el usuario suelta el botón, el código detecta la caída de voltaje y apaga tanto el sonido como la iluminación.
• Modo Simón Dice: El procesador utiliza la memoria interna para almacenar una secuencia de números aleatorios. Después, el Arduino recorre ese listado activando los LEDs y sus frecuencias asociadas y va comparando cada pulsación del usuario con la nota guardada en la memoria para validar si el orden es correcto.
• Modo Piano Tiles: En este modo de juego el sistema elige un LED al azar y registra el tiempo exacto de encendido. Si el usuario no presiona el botón que genera el voltaje correspondiente a esa nota antes de que transcurra el tiempo límite, el procesador activa la lógica de Game Over.
• Modo Reproducción Automática: El usuario selecciona una canción pulsando una de las teclas del piano (se ha asignado una canción diferente a cada botón). Una vez seleccionada, el microcontrolador lee una estructura de datos (struct Cancion) con la partitura programada y ejecuta la melodía, sincronizando cada frecuencia sonora con su LED correspondiente.
• Modo Aprendizaje Guiado: El sistema ilumina el LED de la nota que debe tocarse y detiene la secuencia hasta que se detecta en el pin A0 el voltaje exacto de esa nota. Solo cuando el usuario acierta la tecla correcta, el sistema emite sonido y avanza a la siguiente nota de la canción.

Tanto el modo de Reproducción Automática como el modo de Aprendizaje Guiado tendría el siguiente repertorio de canciones:

• Do: Himno a la Alegría (Beethoven)
• Re: Never Gonna Give You Up (Rick Astley)
• Mi: Harry Potter
• Fa: Star Wars
• Sol: Cumpleaños Feliz
• La: El Rey de la Montaña (Grieg)
• Si: Smoke on the Water (Deep Purple)

3. Sistema de salida (Interfaz de usuario):

La interfaz del usuario combina información auditiva y visual. Por un lado, se tiene el buzzer que es un pequeño altavoz que vibra para crear los distintos sonidos. Por otro lado, la parte visual cuenta con una pantalla LCD que indica el modo de juego y siete luces LEDs que se iluminan cada vez que tocas una nota.

3. PASOS REALIZADOS

Para la construcción del proyecto se siguió un flujo de trabajo dividido en cuatro fases principales:

• Fase 1: Primero se realizó el diseño y se hizo una simulación del sistema utilizando Tinkercad.
• Fase 2: Una vez validado el hardware de forma virtual, se procedió a la programación en el entorno de Arduino.
• Fase 3: Con el código base listo, se trasladó el diseño al plano físico y se montó todo el sistema.
• Fase 4: La fase final se dedicó a hacer distintas pruebas y a pulir el acabado físico del piano.

4. REPARTO DE TAREAS

Para este proyecto, el grupo decidió no trabajar de forma aislada. Optamos por una metodología de desarrollo conjunto, realizando la mayor parte de la implementación en sesiones presenciales en salas de la biblioteca. Esto permitió que todos los miembros tuvieran una visión global del sistema y facilitó la resolución inmediata de errores durante el montaje y la programación.

Un aspecto clave de nuestra metodología fue la toma de decisiones conjunta. Cada vez que surgía un obstáculo técnico (desde un fallo en la lógica del código hasta un reto físico con los componentes) no recaía sobre una sola persona. Los tres nos deteníamos para analizar el problema y pensar en una solución común.

Aun así, para optimizar el tiempo, se establecieron roles de liderazgo en tareas específicas que luego se integraban en el conjunto:

Fase del Proyecto	Líder de Tarea	Colaboración y Apoyo
Simulación y Diseño Virtual	Naroa	Validación conjunta en Tinkercad para asegurar la viabilidad del circuito antes de comprar componentes.
I+D y Escalera de Resistencias	Adrián	Pruebas de concepto con prototipos reducidos (2 botones) para verificar la lógica analógica.
Preparación de Chasis y Acabado	Icíar	Tratamiento físico del material (pintura y diseño estético) para la integración del hardware.
Estructuración del Circuito Real	Naroa	Maquetación y medidas en el chasis de cartón y cables para la disposición de botones, LEDs y LCD.
Ensamblado del Sistema de Salida	Icíar y Adrián	Montaje crítico de la pantalla LCD con la solución de placas en escalera.
Instalación de Periféricos (LED/Res.)	Naroa e Icíar	Cableado de la escalera de resistencias definitiva y la hilera de 7 diodos LED.
Control de Modo y Audio	Adrián y Naroa	Instalación del botón de cambio de modo (D7) y del altavoz mejorado de 8Ω.
Desarrollo y Refinado de Código	Los tres	Implementación de la lógica de los modos, coordinando cambios en durante las pruebas de hardware.

5. COSTES DE LOS MATERIALES

Para la realización del proyecto hemos aprovechado al máximo los recursos disponibles, reutilizando material de la asignatura de primero (Fundamentos Físicos de la Informática) y el kit de componentes proporcionado para este proyecto. Únicamente realizamos una inversión económica para mejorar el acabado estético y la calidad del sonido y la interacción.

Material reutilizado e inventario (Coste 0 €):

La base del proyecto se montó con el material que ya teníamos: la placa Arduino Uno R3, la pantalla LCD 16×2, tres placas protoboard, el cableado jumper y las resistencias necesarias para la escalera de botones y los LEDs. Al contar con este material, pudimos dedicar el presupuesto a mejorar la experiencia de usuario.

Material adquirido para el proyecto:

Compramos componentes específicos para que el piano fuera más funcional y visualmente atractivo. Sustituimos el buzzer estándar por un altavoz con mejor calidad de sonido y compramos pulsadores de mayor tamaño para que fuera más cómodo jugar a los modos «Simón Dice» o «Piano Tiles». También adquirimos un paquete de 100 LEDs de colores para tener repuestos y variedad cromática, además de pintura y pegatinas para personalizar el chasis de cartón.

Concepto	Origen	Inversión
Arduino, LCD, Protoboards, Resistencias y Cables	Kit Asignatura / Material 1º	0,00 €
Altavoz de mayor fidelidad	Compra específica	1,79 €
Pack de 100 LEDs de colores	Compra específica	1,45 €
Pulsadores de gran formato (8 unidades)	Compra específica	2,32 €
Decoración (pintura y pegatinas)	Compra específica	4,58 €
TOTAL INVERTIDO	—	10,14 €

6. PROBLEMAS Y SOLUCIONES ENCONTRADAS

Durante la fase de montaje y prototipado físico, surgieron varios retos relacionados con la gestión del espacio y la integridad de las conexiones. A continuación, se detallan las soluciones de ingeniería aplicadas:

1. Eficiencia en el uso de entradas del microcontrolador
   • Problema: el uso de 7 pines digitales independientes para las notas del piano limitaba la capacidad de expansión del sistema y complicaba el cableado.
   • Solución: se diseñó una escalera de resistencias (divisor de tensión múltiple) conectada a un único pin analógico (A0). Esta solución fue validada previamente mediante simulación en Tinkercad para calcular con precisión los rangos de voltaje de cada pulsador. Gracias a esto, optimizamos el uso de recursos del Arduino y simplificamos drásticamente el bus de datos de entrada.
2. Optimización del bus de tierra (GND)
   • Problema: el elevado número de componentes (7 LEDs, 8 pulsadores, LCD y Buzzer) generaba una saturación de cables conectados a los pines de tierra de la protoboard, dificultando el cierre de la estructura y aumentando el riesgo de desconexiones accidentales.
   • Solución: se diseñó un bus de tierra externo a la placa protoboard. Para ello, se instaló un conductor común longitudinal (situado bajo la cinta de carrocero en el chasis de cartón) donde se centralizaron todas las conexiones de retorno. Esto permitió limpiar el área de trabajo y asegurar un contacto más robusto para los componentes periféricos.
3. Gestión de espacio y conectividad de la pantalla LCD
   • Problema: la integración de la pantalla LCD en el chasis de cartón presentaba un reto mecánico significativo. Los cables que venían con el kit proporcionado poseen conectores de plástico rígidos y voluminosos que aumentaban excesivamente la altura del conjunto. Esto impedía que la pantalla quedara a ras de la superficie del piano y generaba tensiones mecánicas que comprometían la estabilidad de las conexiones, dificultando un acabado estético limpio y funcional.
   • Solución: para que la pantalla quedara plana y bien encajada, decidimos usar dos placas protoboard en forma de escalera. En lugar de usar los cables típicos, fabricamos nuestros propios conectores usando clips metálicos. Cortamos los clips a la medida exacta y los doblamos para conectar los pines de la pantalla directamente a la placa de abajo. Al ser rígidos y estar bien separados, conseguimos tres cosas:
     • Ahorrar espacio: Redujimos la altura del cableado casi al mínimo, dejando la pantalla integrada en el cartón.
     • Estabilidad: Los clips no se mueven como los cables, así que no hay fallos de conexión.
     • Orden: Dejamos la zona de la pantalla limpia de cables «altos», llevando las conexiones largas al Arduino desde la placa de abajo.
4. Ruptura de una patilla del botón durante la grabación de los vídeos
   • Problema: durante la grabación de los vídeos, se produjo la rotura de una de las patillas que conectaba la línea de botones con el pin analógico A0 de la placa Arduino, interrumpiendo la continuidad del circuito.
   • Solución: se realizó un puenteado alternativo cruzando la resistencia y el cableado. Esto permitió aprovechar el terminal funcional del mismo lado del componente, restableciendo la conexión con el pin A0 sin necesidad de sustituir la pieza dañada.

7. CÓDIGO

El código se organiza alrededor de un sistema de modos controlado por un único botón, que cambia el comportamiento del programa entre distintas experiencias musicales y de juego. En el loop() principal se detecta ese cambio y se ejecuta una función distinta según el modo activo: desde un piano libre, hasta juegos como Simon o Tiles, o la reproducción/aprendizaje de canciones. La lógica central se basa en leer entradas analógicas para identificar qué tecla se pulsa, asociarla a una nota y a un LED, y generar sonido con el buzzer mientras se muestra feedback en la pantalla LCD. Los modos de juego añaden capas de lógica: Simon construye y verifica secuencias progresivas, Tiles exige reacción rápida dentro de un tiempo límite que se reduce dinámicamente, y el modo canciones recorre arrays de melodía y duración para reproducir o guiar al usuario paso a paso.

#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

const int pinEscalera = A0;
const int pinBuzzer = 6;
const int pinBotonModo = 7;
const int leds[] = {8, 9, 10, A1, A2, A3, A4}; 

int notas[] = {262, 294, 330, 349, 392, 440, 494}; 
String nombresNotas[] = {"DO", "RE", "MI", "FA", "SOL", "LA", "SI"};

int modo = 0; 
int ultimoEstadoBotonModo = LOW;
bool cambioSolicitado = false;
int recordSimon = 0;
int recordTiles = 0;
int puntuacionActual = 0;
int secuencia[40]; 

struct Cancion {
  String nombre;
  int melodia[40]; 
  int tiempos[40];
  int largo;
};

// --- REPERTORIO (0=DO, 1=RE, 2=MI, 3=FA, 4=SOL, 5=LA, 6=SI) ---
Cancion canciones[7] = {
  // DO: HIMNO A LA ALEGRÍA
  {"ALEGRIA", {2,2,3,4,4,3,2,1,0,0,1,2,2,1,1}, {400,400,400,400,400,400,400,400,400,400,400,400,450,150,700}, 15},

  // RE: RICKROLL
  {"RICKROLL", {0,1,3,1,5,5,4,0,1,3,1,4,4,3,2,0,1,3,1,3,4,2,0,1,2,0}, {200,200,200,200,400,400,600,200,200,200,200,400,400,400,600,200,200,200,200,300,300,500,200,200,200,800}, 26},

  // MI: HARRY POTTER
  {"HARRY POTTER", {4,0,3,2,0,4,3,2,6,4,0,3,2,1,5}, {300,450,150,300,600,300,600,450,150,900,450,150,300,600,900}, 15},

  // FA: STAR WARS
  {"STAR WARS", {0,4,3,2,1,6,4,3,2,1,6,4,3,2,3,1}, {400,400,150,150,150,400,400,150,150,150,400,400,150,150,150,800}, 16},

  // SOL: CUMPLEAÑOS FELIZ
  {"CUMPLE FELIZ", {0,0,1,0,3,2,0,0,1,0,4,3}, {200,200,400,400,400,800,200,200,400,400,400,800}, 12},

  // LA: EL REY DE LA MONTAÑA 
  {"REY MONTANA", {0,1,2,3,4,2,4,3,2,3,2,0,1,2,3,4,2,4,6,5,4,2,4,3,2,3,2}, {300,300,300,300,300,300,600,300,300,600,300,300,300,300,300,300,300,300,300,600,300,300,600,300,300,600,800}, 27},

  // SI: SMOKE ON THE WATER
  {"SMOKE ON WATER", 
    {0,2,3,0,2,4,3,0,2,3,2,0}, 
    {400,400,600,400,400,200,800,400,400,600,400,1000}, 12}
};

void setup() {
  lcd.begin(16, 2);
  pinMode(pinBotonModo, INPUT);
  pinMode(pinBuzzer, OUTPUT);
  for(int i=0; i<7; i++) pinMode(leds[i], OUTPUT);
  randomSeed(analogRead(A5));
  mostrarPantallaInicio(); 
}

void loop() {
  checkBotonModo(); 
  if (cambioSolicitado) { prepararModo(); cambioSolicitado = false; }

  switch(modo) {
    case 0: ejecutarLibre(); break;
    case 1: ejecutarSimon(); break;
    case 2: ejecutarTilesInfinito(); break;
    case 3: menuSeleccion(false); break; 
    case 4: menuSeleccion(true); break;  
  }
}

// --- MODOS DE JUEGO ---

void ejecutarSimon() {
  puntuacionActual = 0;
  while(true) {
    lcd.clear(); lcd.print(F("Simon - Niv: ")); lcd.print(puntuacionActual + 1);
    delay(800);
    secuencia[puntuacionActual] = random(0, 7);
    puntuacionActual++;
    for (int i = 0; i < puntuacionActual; i++) {
      int n = secuencia[i];
      digitalWrite(leds[n], HIGH); tone(pinBuzzer, notas[n]);
      delay(400); digitalWrite(leds[n], LOW); noTone(pinBuzzer); delay(150);
    }
    for (int i = 0; i < puntuacionActual; i++) {
      int resp = -1;
      while(resp == -1) {
        checkBotonModo(); if(cambioSolicitado) return;
        resp = leerBoton();
      }
      digitalWrite(leds[resp], HIGH); tone(pinBuzzer, notas[resp]);
      while(leerBoton() != -1); 
      noTone(pinBuzzer); digitalWrite(leds[resp], LOW);
      if (resp != secuencia[i]) { gameOver(recordSimon); return; }
    }
    if(puntuacionActual % 5 == 0) musicaMotivacion();
    delay(500);
  }
}

void ejecutarTilesInfinito() {
  puntuacionActual = 0;
  int tiempoLimite = 1500;
  while(true) {
    int n = random(0, 7);
    lcd.clear(); lcd.print(F("TILES! Pts: ")); lcd.print(puntuacionActual);
    digitalWrite(leds[n], HIGH);
    unsigned long start = millis();
    bool acertado = false;
    while(millis() - start < tiempoLimite) {
      checkBotonModo(); if(cambioSolicitado) { apagarLeds(); return; }
      if(leerBoton() == n) { acertado = true; break; }
    }
    if(acertado) {
      tone(pinBuzzer, notas[n], 100); apagarLeds();
      puntuacionActual++;
      tiempoLimite = max(350, 1500 - (puntuacionActual * 45));
      delay(150);
    } else { gameOver(recordTiles); return; }
  }
}

void menuSeleccion(bool interactivo) {
  lcd.clear(); lcd.print(F("ELIGE CANCION:"));
  lcd.setCursor(0,1); lcd.print(F("PULSA DO-SI"));
  int elegida = -1;
  while(elegida == -1) {
    checkBotonModo(); if (cambioSolicitado) return;
    elegida = leerBoton();
  }
  if (interactivo) ejecutarAprendizaje(elegida);
  else ejecutarAutomatico(elegida);
}

void ejecutarAprendizaje(int idx) {
  lcd.clear(); lcd.print(F("TOCA: ")); lcd.setCursor(0,1); lcd.print(canciones[idx].nombre);
  for (int i = 0; i < canciones[idx].largo; i++) {
    int obj = canciones[idx].melodia[i];
    digitalWrite(leds[obj], HIGH);
    int pulsado = -1;
    while (pulsado != obj) {
      checkBotonModo(); if (cambioSolicitado) { apagarLeds(); return; }
      pulsado = leerBoton();
    }
    tone(pinBuzzer, notas[obj]);
    while(leerBoton() != -1); noTone(pinBuzzer);
    digitalWrite(leds[obj], LOW); delay(100);
  }
  victoria();
}

void ejecutarAutomatico(int idx) {
  lcd.clear(); lcd.print(F("OYE: ")); lcd.print(canciones[idx].nombre);
  for (int i = 0; i < canciones[idx].largo; i++) {
    int n = canciones[idx].melodia[i];
    digitalWrite(leds[n], HIGH); tone(pinBuzzer, notas[n]);
    unsigned long st = millis();
    while(millis() - st < canciones[idx].tiempos[i]) {
      checkBotonModo(); if (cambioSolicitado) { noTone(pinBuzzer); return; }
    }
    noTone(pinBuzzer); digitalWrite(leds[n], LOW); delay(50);
  }
  delay(1200);
}

// --- UTILIDADES ---

void gameOver(int &record) {
  lcd.clear(); lcd.print(F("GAME OVER"));
  lcd.setCursor(0,1); lcd.print(F("Pts: ")); lcd.print(puntuacionActual);
  if(puntuacionActual > record && puntuacionActual > 0) {
    record = puntuacionActual;
    musicaRecord();
  } else {
    tone(pinBuzzer, 150, 800); delay(1500);
  }
  prepararModo();
}

void musicaRecord() {
  lcd.clear(); lcd.print(F("NUEVO RECORD!"));
  for(int i=0; i<4; i++) { tone(pinBuzzer, notas[i*2], 200); delay(250); }
}

void musicaMotivacion() {
  lcd.clear(); lcd.print(F("¡GENIAL!"));
  for(int i=0; i<3; i++) { tone(pinBuzzer, 600, 100); delay(150); }
}

void victoria() { lcd.clear(); lcd.print(F("¡PERFECTO!")); delay(1200); }

int leerBoton() {
  int v = analogRead(pinEscalera);
  if (v < 100) return -1;
  if (v > 980) return 0;
  if (v >= 880 && v <= 980) return 1;
  if (v >= 800 && v < 880) return 2;
  if (v >= 755 && v < 800) return 3;
  if (v >= 700 && v < 755) return 4;
  if (v >= 655 && v < 700) return 5;
  if (v >= 550 && v < 655) return 6;
  return -1;
}

void checkBotonModo() {
  int lectura = digitalRead(pinBotonModo);
  if (lectura == HIGH && ultimoEstadoBotonModo == LOW) {
    modo++; if (modo > 4) modo = 0;
    cambioSolicitado = true; delay(300);
  }
  ultimoEstadoBotonModo = lectura;
}

void ejecutarLibre() {
  int b = leerBoton();
  if (b != -1) {
    tone(pinBuzzer, notas[b]); digitalWrite(leds[b], HIGH);
    lcd.setCursor(0,1); lcd.print(F("Nota: ")); lcd.print(nombresNotas[b]); lcd.print(F("   "));
  } else {
    noTone(pinBuzzer); apagarLeds();
    lcd.setCursor(0,1); lcd.print(F("Toca una tecla  "));
  }
}

void apagarLeds() { for(int i=0; i<7; i++) digitalWrite(leds[i], LOW); }

void prepararModo() {
  noTone(pinBuzzer); apagarLeds();
  lcd.clear(); lcd.print(F("MODO:"));
  lcd.setCursor(0,1);
  const char* msjs[] = {"1.LIBRE", "2.SIMON", "3.TILES", "4.AUTO", "5.APRENDER"};
  lcd.print(msjs[modo]);
  delay(1000);
}

void mostrarPantallaInicio() {
  lcd.clear();
  lcd.print(F(" PIANO ARCADE"));
  lcd.setCursor(0, 1);
  lcd.print(F("  SEyTR 2026"));
  for (int i = 0; i < 7; i++) {
    digitalWrite(leds[i], HIGH);
    tone(pinBuzzer, notas[i]);
    delay(100);
    noTone(pinBuzzer);
  }
  for (int i = 6; i >= 0; i--) {
    digitalWrite(leds[i], LOW);
    delay(50);
  }
}

8. CASOS DE USO

El sistema desarrollado en Arduino tiene cinco casos de uso principales que representan los distintos modos de funcionamiento del dispositivo, permitiendo al usuario interactuar mediante botones, LEDs, pantalla LCD y sonido.

1. El primer caso es «Modo Libre», que funciona como un piano básico. Al pulsar cualquier tecla de la escalera de resistencias, el sistema reproduce la nota sonora, enciende el LED asociado y muestra su nombre en la pantalla LCD. Este modo permite una interacción directa sin reglas ni objetivos.
2. El segundo caso es «Modo Simón», un juego de memoria secuencial. El sistema genera una secuencia aleatoria de luces y sonidos que el usuario debe repetir correctamente. La dificultad aumenta progresivamente con cada acierto, y el juego termina si se comete un error, mostrando la puntuación obtenida.
3. El tercer caso es «Modo Tiles Infinito», un reto de agilidad mental. El sistema ilumina un LED al azar y el usuario debe pulsar la tecla correspondiente antes de que se agote un tiempo límite. Con cada acierto, el tiempo disponible se reduce, aumentando la velocidad y el desafío.
4. El cuarto caso es «Modo Reproducción Automática», diseñado para la escucha del repertorio. El usuario selecciona una canción y el sistema la ejecuta de forma autónoma, coordinando el sonido del buzzer con la iluminación rítmica de los LEDs.
5. Finalmente, el quinto caso es «Modo Aprendizaje Guiado», que actúa como un tutor interactivo. El sistema ilumina el LED de la nota que debe pulsarse y detiene la melodía hasta que el usuario acierta la tecla correcta, permitiendo aprender las canciones paso a paso.

9. CIRCUITO TINKERCAD

El diseño en Tinkercad no fue solo un paso previo para cumplir con la entrega, sino nuestra herramienta principal para no cometer errores críticos en el montaje real. Al ser tres personas trabajando a la vez, el modelo virtual nos sirvió como mapa oficial para que todos supiéramos dónde iba cada conexión mientras montábamos el piano físico.

Una de las mayores utilidades de Tinkercad fue ayudarnos a gestionar qué materiales necesitábamos comprar y cuáles no. Al probar el circuito online, pudimos confirmar cuántos LEDs y resistencias íbamos a usar exactamente antes de ir a la tienda. Esto nos permitió ahorrar presupuesto, asegurándonos de que cada componente nuevo (como los botones grandes o el pack de LEDs) encajaría perfectamente con el material que ya teníamos de primero, como el Arduino o la LCD.

Aunque la simulación funcionaba muy bien, al pasar los componentes al cartón nos dimos cuenta de que la realidad pedía algunos cambios. El ajuste más importante fue el de las resistencias de los LEDs. En el diseño original de Tinkercad pusimos resistencias de 220 Ω, pero al montarlo vimos que los LEDs brillaban demasiado y podían forzar un poco el consumo del Arduino con todo lo demás conectado. Por eso, decidimos subirlas a 300 Ω. Con este cambio conseguimos que el piano fuera más seguro para la placa y que los LEDs tuvieran una luz más agradable pero suficiente para jugar.

También usamos el simulador para clavar los valores de la escalera de resistencias. Gracias a las pruebas virtuales, pudimos elegir los valores de 1 kΩ sabiendo de antemano que el Arduino distinguiría bien los voltajes de cada nota en el pin A0. Esto nos ahorró muchísimas horas de ensayo y error con el polímetro en la biblioteca, permitiéndonos ir directos al montaje definitivo.

A continuación, se adjunta una imagen del circuito creado en Tinkercad y que se usó como guía en el montaje físico.

10. VÍDEOS

Caso de uso 1 – Modo Libre:

Caso de uso 2 – Modo Simón Dice:

Caso de uso 3 – Modo Piano Tiles:

Caso de uso 4 – Modo Reproducción Automática:

Caso de uso 5: Modo Aprendizaje Guiado