Construye un Piano Táctil Capacitivo Portátil con Arduino – Guía Paso a Paso

Componentes y suministros

Componente	Cantidad
Caja ProtoStax para Arduino	1
Shield Capacitivo 12x para Arduino - MPR121 (Adafruit)	1
Zumbador Piezo Adafruit - PS1240	1
Arduino UNO	1
Cinta de cobre con adhesivo conductor	1
Kit de cable de conexión, 22 AWG	1

Sobre el proyecto

En este proyecto explico cómo construir un piano táctil capacitivo portátil con:

• un Arduino,
• un Shield Táctil Capacitivo para Arduino usando el MPR121,
• un zumbador piezo,
• cinta de cobre con adhesivo conductor (cortada en forma de teclas de piano),

todo encerrado en una caja de acrílico transparente (ProtoStax para Arduino) con las teclas capacitivas pegadas en su superficie superior. Esto crea un pequeño piano compacto que puedes llevar y tocar, ¡y programar nuevas melodías!

Para la detección táctil capacitiva, uso el Shield Táctil Capacitivo 12x de Adafruit para Arduino usando el MPR121, junto con la librería Adafruit_MPR121 que facilita detectar y responder toques en hasta 12 superficies conductoras diferentes.

¡Espera un minuto! Hay 12 semitonos en una octava - Do, Do#, Re, Re#, Mi, Fa, Fa#, Sol, Sol#, La, La#, Si. ¡Perfecto! Bueno, habría sido genial si el MPR121 manejara 13 entradas - nos habría permitido ir de Do al Do de la octava superior, ¡pero aún hay muchas melodías posibles! (y también ofrezco sugerencias abajo para expandir el rango de octavas).

Además, también puedes programar tus propias secuencias de toque ("Llaves Secretas" o combinaciones de teclas) para tocar cualquier melodía aleatoria que pueda incluir tantas octavas como quieras (limitado solo por la capacidad de tu oído para escuchar las notas, o tu piezo/altavoz para reproducirlas).

Para la salida, uso la librería tone de Arduino para reproducir el sonido a través de un zumbador piezo. También puedes usar un altavoz - solo recuerda usar una resistencia para limitar la corriente a la que puede proporcionar el pin del Arduino.

Para las teclas del piano, uso cinta de cobre con adhesivo conductor. Es importante conseguirla con adhesivo conductor ya que vas a pegar la cinta sobre el cable conectado al shield.

Por último viene la caja. Algunos de ustedes sabrán que he creado un nuevo sistema de cajas modulares y apilables llamado ProtoStax. Fue una necesidad personal: quería una caja que soportara diferentes etapas de prototipado, ofreciendo protección y acceso abierto al empezar, con la capacidad de añadir paredes laterales y tapa después, pero también poder apilar múltiples unidades lado a lado o una sobre otra, expandiéndose con las necesidades de prototipado y la adición de otras placas y componentes.

En este ejemplo uso ProtoStax para Arduino, una caja de acrílico transparente para Arduino - que encaja tanto en la huella Uno/Leonardo como en la más grande Mega/Due - que también es apilable y modular y tiene espacio cómodo para los dos shields (con algunas modificaciones menores que describiré). Es transparente, resistente y tiene patas de goma para elevarlo ligeramente y proteger la superficie de tu mesa. La superficie superior de la caja también actúa como teclado para tu piano táctil - ¡aquí es donde pegarás tu cinta de cobre conductora! Al final, tendrás un piano táctil genial que puedes llevar fácilmente, exhibir y tocar. 😊

¡Empecemos, ¿de acuerdo? 😊

Paso 1 - Montar el Arduino en la placa base de la caja

Primero montemos el Arduino (Uno en nuestro ejemplo) en la placa base de la caja. Esto le da protección mientras ofrece acceso abierto total para configurar y preparar el Arduino y experimentar con él. Cuando estés listo para cerrarlo, es fácil añadir las paredes laterales y la placa superior y asegurar todo con tornillos.

Monta el Arduino en la placa base, añade patas y otro hardware para preparar la caja en Configuración de Plataforma. Ver pasos abajo en la presentación - el pie de foto de cada imagen está numerado y da explicaciones adicionales para cada paso.

Aquí están todos los pasos como GIF animado:

Paso 2 - Preparar el shield MPR121 para el Arduino

Corté a medida 12 piezas de cable trenzado 22 AWG. Luego las soldé en el Shield MPR121. El shield de Adafruit tiene dos agujeros grandes para cada una de las 12 entradas para usar con pinzas de cocodrilo. Entre estos dos agujeros hay uno más pequeño que admite un cable 22 AWG.

El shield MPR121 también expone todos los pines mediante agujeros junto a los headers. También soldé un zumbador piezo PS1240, con una pata en el pin 12 y la otra en GND.

Me aseguré de pelar el otro extremo (libre) de cada cable. Usé un patrón repetitivo de 6 colores diferentes para las 12 entradas, para codificarlas por color y mantener el orden al ensamblar.

Paso 3 - Preparar la caja

A continuación, preparamos la caja. Empezamos insertando el shield en el Arduino montado en la placa base. Luego insertamos los elementos de refuerzo superior y las paredes laterales en las ranuras.

He tomado la tapa original de la caja ProtoStax para Arduino y le he añadido 12 agujeros para pasar los cables de las entradas del shield. Usé una cortadora láser para cortar los agujeros siguiendo la plantilla de teclas de piano, pero puedes usar taladro igualmente (asegúrate de usar cinta de enmascarar en la placa de acrílico antes de taladrar). Un agujero pequeño de 1/8" debería ser suficiente.

Luego inserto cuidadosamente los cables del shield en los agujeros de la tapa superior - me aseguro de insertar el cable del agujero 0 en el agujero más a la izquierda, e inserto progresivamente los cables numerados (están numerados en el shield) en los agujeros de izquierda a derecha. Luego añado los separadores superiores debajo de la tapa superior, y atornillo el tornillo superior para completar la caja.

A continuación, empujo los cables hacia atrás hasta que solo las partes metálicas sobresalgan.

Luego recorto piezas de un rollo de cinta de cobre con adhesivo conductor en forma de teclas de piano según la plantilla (ver abajo). Luego retiro cuidadosamente la cinta de cobre y la pego en sus respectivas posiciones en la tapa superior de la caja, asegurándome de que la cinta de cobre cubra el cable correspondiente que sobresale del agujero.

Aquí está la plantilla para las teclas de piano y los agujeros. Deberías poder imprimir esto en papel Carta 8.5x11 y tener el tamaño correcto (avísame si tienes problemas).

Al final, se ve así: (podría haber hecho un mejor trabajo con la cinta de cobre, pero era mi primera vez usándola, ¡esperemos que mejore en el futuro! 😊)

Paso 4 - Código de demostración

Primero necesitarás instalar la librería Adafruit_MPR121. Después, puedes compilar y subir el sketch de ejemplo, que convierte tu creación en un piano táctil, e incluye combinaciones de teclas secretas para tocar algunas melodías.

• Pulsa Do Mi Si Do# para tocar "Estrellita ¿Dónde Estás?"
• Pulsa Do Re Mi Fa Sol para tocar escala arriba y abajo
• Pulsa Do Re La Si para tocar "¡Oh Susana!"
• Pulsa Do Do# La# Si para tocar "Frère Jacques / Hermano Juan"

También he facilitado que transcribas tus propias melodías de la partitura.

Si te interesa leer más sobre el código (¡y sé que sí!), ¡sigue leyendo!

Repasemos rápidamente las partes principales del código. Puedes consultar el código demo aquí: GitHub

El código se divide en 3 partes:

• Obtener datos táctiles del MPR121 usando la librería Adafruit_MPR121.
• Decidir qué hacer con los datos táctiles - tocar el tono correspondiente como un piano, o detectar multi-toques y tocar la melodía secreta, ambos usando la librería tone integrada.
• Programar melodías, incluyendo cómo añadir las tuyas propias.

Aquí tienes un vistazo rápido a la parte capacitiva del código. Como es típico, declaras un objeto de la clase Adafruit_MPR121. En setup(), llamas al método begin() para inicializarlo, y obtienes los pads tocados actualmente en loop() usando el método cap.touched(). ¡Simple!

Adafruit_MPR121 cap = Adafruit_MPR121();

void setup() {
  ...
  // La dirección por defecto es 0x5A, si está conectado a 3.3V es 0x5B
  // Si está conectado a SDA es 0x5C y si a SCL entonces 0x5D
  if (!cap.begin(0x5A)) {
    Serial.println("MPR121 not found, check wiring?");
    while (1);
  }
  ...
}

void loop() {
  // Obtener pads tocados actualmente
  currtouched = cap.touched();
}

Con los datos táctiles, puedes responder a un toque reproduciendo el tono correspondiente, y detener el tono cuando el botón no se presiona:

// si *está* tocado y *no estaba* tocado antes, ¡toca el tono correspondiente!
if ((currtouched & _BV(i)) && !(lasttouched & _BV(i))) {
  tone(TONE_PIN, scale[i]);
}

// si *estaba* tocado y ahora *no lo está*, y además, ningún botón está presionado, detiene el tono
// Esto permite transiciones suaves entre notas al deslizar el dedo sobre las teclas
// También permite sostener una nota dada, tocando cualquier tecla y manteniéndola tocada - puedes presionar otra tecla y sonará esa, pero no se detendrá hasta que sueltes la primera - ¡como el pedal de sustain del piano!
if (!(currtouched & _BV(i)) && (lasttouched & _BV(i)) && !currtouched) {
  noTone(TONE_PIN);
}

Manejo de multi-toques de teclas especiales reproduciendo la melodía correspondiente:

// ¡Toca melodías si se presiona nuestra combinación 'secreta' de teclas!
if (currtouched == 2193) { // Do Mi Si Do#
  playTune(melody, MELODY_LENGTH(melody), 2); // Toca "Estrellita ¿Dónde Estás?"
} else if (currtouched == 181) { // Do Re Mi Fa Sol
  playTune(melody2, MELODY_LENGTH(melody2), 48); // Toca escala sube y baja
} else if (currtouched == 2565) { // Do Re La Si
  playTune(melody3, MELODY_LENGTH(melody3), 1); // Toca "¡Oh Susana!"
} else if (currtouched == 3075) { // Do Do# La# Si
  playTune(melody4, MELODY_LENGTH(melody4), 1); // Toca "Frère Jacques"
} else {
  ...
}

playTune() se usa para tocar una melodía dada, que es un array de "Nota"s:

void playTune(Note *m, int mSize, int speedUp) {
  noTone(TONE_PIN); // Empezar con pizarra limpia
  for (int thisNote = 0; thisNote < mSize; thisNote++) {
    // Para calcular la duración de la nota, toma un segundo multiplicado por el tipo de nota.
    // ej. negra = 1000.0 * 0.25, corchea = 1000 * 1/8 (0.125), etc.
    // reduce la duración por el factor speedup para aumentar la velocidad
    int noteDuration = 1000.0 * m[thisNote].duration / speedUp;
    tone(TONE_PIN, m[thisNote].frequency, noteDuration);
    
    // Para distinguir las notas, establece un tiempo mínimo entre ellas.
    // la duración de la nota + 30% parece funcionar bien:
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
    noTone(TONE_PIN);
  }
  delay(100);
}

Veamos una melodía - consiste en un array de Notas. Cada Nota tiene una frecuencia y una duración:

typedef struct Note {
  int frequency;
  float duration;
} Note;

// Esta melodía toca todas las notas de la octava de Do a Si y vuelta a Do
Note melody2[] = {
  {NOTE_C, NOTE_WHOLE}, {NOTE_CS, NOTE_WHOLE}, {NOTE_D, NOTE_WHOLE},
  {NOTE_DS, NOTE_WHOLE}, {NOTE_E, NOTE_WHOLE}, {NOTE_F, NOTE_WHOLE},
  {NOTE_FS, NOTE_WHOLE}, {NOTE_G, NOTE_WHOLE}, {NOTE_GS, NOTE_WHOLE},
  {NOTE_A, NOTE_WHOLE}, {NOTE_AS, NOTE_WHOLE}, {NOTE_B, NOTE_WHOLE},
  {NOTE_AS, NOTE_WHOLE}, {NOTE_A, NOTE_WHOLE}, {NOTE_GS, NOTE_WHOLE},
  {NOTE_G, NOTE_WHOLE}, {NOTE_FS, NOTE_WHOLE}, {NOTE_F, NOTE_WHOLE},
  {NOTE_E, NOTE_WHOLE}, {NOTE_DS, NOTE_WHOLE}, {NOTE_D, NOTE_WHOLE},
  {NOTE_CS, NOTE_WHOLE}, {NOTE_C, NOTE_WHOLE}
};

Aquí es donde los #define en pitches.h y noteDurations.h son útiles. Puedes usarlos en lugar de las frecuencias y duraciones reales. Por ejemplo, usa NOTE_C para tocar un Do, y NOTE_WHOLE para tocarlo como redonda (NOTE_HALF, NOTE_QUARTER, NOTE_EIGHTH son otras duraciones). También puedes usar la macro DOTTED() para especificar una nota "con punto" - como DOTTED(NOTE_QUARTER).

[Nota: Una nota con punto es una nota cuya duración se extiende con otra nota de la mitad de su duración - por ejemplo, una blanca con punto equivale a 3/4 de redonda (1/2 nota más 1/2 de 1/2 nota).]

¡Esto te permite tomar cualquier partitura y transcribirla a tu array de melodía!

En la demo, he transcrito "Estrellita ¿Dónde Estás?", "Frère Jacques/Hermano Juan" y "¡Oh Susana!" para que tengas algo con qué jugar (¡sin juego de palabras! 😜) - todas estas canciones caben en una octava, que es la restricción de nuestro teclado que intenté respetar. Por supuesto, al tocar una melodía secreta, no estás limitado por esto y puedes usar múltiples octavas. "¡Oh Susana!" es también un poco más compleja, usando blancas, negras, corcheas y también negras y blancas con punto - ¡esperemos que esto te ayude a sentir cómo transcribir otras melodías fácilmente!

¡Veámoslo en acción, ¿de acuerdo? 😊

Paso 5 - ¡Llévalo más lejos!

Aquí hay algunas ideas para llevar el proyecto aún más lejos:

1. Crea tus propias melodías/jingles (o transcribe existentes) y asigna tus propias "Llaves Secretas" para activarlas.
2. Añade un segundo piezo para sonidos polifónicos de 2 niveles. La librería tone usa el Timer2 para enviar una onda cuadrada al piezo. El Arduino Uno tiene 3 timers, aunque el Timer 0 es especial y se usa para millis() y PWM. Eso nos deja el Timer1. La librería NewTone es una reescritura optimizada de tone que usa Timer1. Así puedes tener dos tonos a la vez, uno usando tone y otro NewTone.
3. Añade un botón extra o dos para funcionalidad adicional - como usar el botón para extender la octava a la superior o inferior. Presionando estos botones junto con tus teclas capacitivas, ¡puedes tener un rango mayor en tu teclado!

¿Se te ocurren más? ¡Escribe un comentario abajo para avisarnos! 😊 Siéntete libre de hacer cualquier pregunta. 😊

¡Feliz creación! 😊

Código

ProtoStax_CapacitiveTouch_Piano_Demo

Demo para piano ProtoStax con caja ProtoStax para Arduino, Shield Capacitivo 12x Adafruit MPR121, zumbador piezo y Arduino.

https://github.com/protostax/ProtoStax_CapacitiveTouch_Piano_Demo.git

Partes personalizadas y cajas

Plantilla para cortar teclas de piano para ProtoStax Capacitive Touch Piano y taladrar agujeros en la tapa superior.

Esquemáticos