Piano táctil capacitivo portátil

Acerca de este proyecto

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

• un Arduino,
• una pantalla táctil capacitiva para Arduino usando el MPR121,
• un zumbador piezoeléctrico,
• cinta de lámina 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 táctiles capacitivas pegadas en su superficie superior. ¡Esto lo convierte en un bonito y pequeño piano que puedes tocar, tocar y codificar nuevas melodías!

Para la detección táctil capacitiva, utilizo 12 x Capacitive Touch Shield de Adafruit para Arduino usando el MPR121, junto con la biblioteca Adafruit_MPR121 que hace que sea fácil de detectar y responder a toques en hasta 12 superficies conductoras diferentes.

¡Espera un minuto! Hay 12 semitonos en una octava:C, C #, D, D #, E, E #, F, G, G #, A, A #, B! ¡Perfecto! Bueno, hubiera sido genial si el MPR121 manejara 13 entradas - nos hubiera permitido ir de C a C de la octava más alta, ¡pero todavía hay muchas melodías disponibles! (y también ofrezco sugerencias a continuación sobre cómo puede llevar este proyecto más lejos al expandir el rango de octavas)

Además, también puede programar en sus propias secuencias táctiles ("Teclas secretas" o combinaciones de teclas) para tocar cualquier melodía aleatoria que pueda incluir tantas octavas como desee (limitado solo por el poder de su oído para escuchar las notas, o su piezo / altavoz para reproducirlo!).

Para la salida, uso la biblioteca de tonos de Arduino para reproducir el sonido a través de un zumbador piezoeléctrico. También puede usar un altavoz, ¡solo recuerde usar una resistencia con él para restringir la corriente a la que puede proporcionar el pin de Arduino!

Para las teclas del piano, utilizo cinta de lámina de cobre con adhesivo conductor. Es importante conseguirlo con adhesivo conductor ya que vas a pegar la cinta en el cable que está conectado al blindaje.

Por último llega el recinto. Algunos de ustedes pueden saber que he creado un nuevo sistema de gabinete modular apilable llamado ProtoStax. Era una picazón personal que tenía que rascar:quería un gabinete que soportara diferentes etapas de creación de prototipos, que ofreciera protección y acceso abierto al comenzar, con la capacidad de agregar paredes laterales y la parte superior más tarde, pero también que tuviera la capacidad de apilar múltiples unidades, una al lado de la otra o una encima de la otra, por lo que tienen la capacidad de expandirse con las necesidades de creación de prototipos y la adición de otras placas y componentes.

En este ejemplo, utilizo ProtoStax para Arduino, una carcasa de acrílico transparente para Arduino, que se adapta tanto a la huella Uno / Leonardo como a la huella Mega / Due más grande, que también es apilable y modular y tiene espacio para los dos. Escudos (con algunas modificaciones menores, que describiré). Es transparente y resistente y también tiene pies de goma para elevarlo ligeramente y proteger la superficie de su mesa. La superficie superior del gabinete también actúa como el teclado para su piano táctil; aquí es donde pegará su cinta de lámina de cobre conductora. ¡Al final, tendrás un pequeño piano táctil ingenioso que puedes llevar fácilmente, exhibir y tocar! 😊

Ok, comencemos, ¿de acuerdo? 😊

Paso 1:monte el Arduino en la placa base del gabinete

Primero montemos el Arduino (Uno en nuestro ejemplo) en la placa base del gabinete. Esto le brinda protección al tiempo que ofrece acceso abierto completo para configurar y configurar el Arduino y jugar con él. Cuando esté listo para cerrarlo, es fácil agregar las paredes laterales y la placa superior y asegurar todo con tornillos.

Monte el Arduino en la placa base y agregue pies y otro hardware para preparar el gabinete en Configuración de plataforma . Vea los pasos a continuación en la presentación de diapositivas:el título de cada imagen está numerado y brinda una explicación adicional para cada paso.

Aquí están todos los pasos como un gif animado:

Paso 2:prepara el protector MPR121 para Arduino

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

El MPR121 Shield también expone todos los pines a través de orificios al lado de los encabezados. También soldé en un Piezo Buzzer PS1240, con una pata insertada en el pin 12 y la otra en GND.

Me aseguré de pelar el otro extremo (libre) de cada uno de los cables. Usé un patrón repetido de 6 colores diferentes para las 12 entradas, para codificarlas por colores, de modo que el orden se pudiera mantener más tarde al ensamblar.

Paso 3:preparar el gabinete

A continuación, tenemos que preparar el recinto. Comenzamos insertando el escudo en el Arduino montado en la placa base. Luego insertamos los elementos de refuerzo superiores y las paredes laterales en las ranuras de la pared.

Tomé la parte superior original de la carcasa ProtoStax para Arduino y le agregué 12 orificios para insertar los cables de las entradas del blindaje. Usé un cortador láser para cortar los agujeros que coinciden con la plantilla de la tecla del piano, pero puedes usar un taladro con la misma facilidad (solo asegúrate de usar cinta adhesiva en la placa acrílica antes de perforar). Un agujero pequeño de 1/8 "debería ser suficiente.

Luego inserto con cuidado los cables del blindaje en los orificios de la placa superior; me aseguro de insertar el cable desde el orificio 0 hasta el orificio más a la izquierda, e inserto cables numerados progresivamente (están numerados en el blindaje) en los orificios de izquierda a derecha. Luego agrego los espaciadores superiores debajo de la placa superior y atornillo la parte superior del tornillo para completar el gabinete.

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

Luego corté piezas de un rollo de lámina de cobre con adhesivo conductor en la forma de las teclas del piano de la plantilla (vea la plantilla a continuación). Luego, despego con cuidado la lámina de cobre y la pego en sus respectivas posiciones en la placa superior del gabinete, asegurándome de que la cinta de cobre se pegue sobre el cable correspondiente que sobresale del orificio.

Aquí está la plantilla para las teclas del piano y los agujeros. Debería poder imprimir esto en papel Carta de 8.5x11 y tener el tamaño correcto (¡avíseme si tiene problemas!)

Al final, se ve así:(Podría haber hecho un mejor trabajo con la cinta de lámina de cobre, pero esta fue la primera vez que la usé, ¡así que espero mejorar con su manejo en el futuro! 😊)

Paso 4:código de demostración

Primero deberá instalar la biblioteca Adafruit_MPR121. Después de eso, puede compilar y cargar el boceto de ejemplo, que convierte su creación en un piano táctil e incluye combinaciones de teclas secretas para reproducir algunos jingles.

• Pulsa C E G B para reproducir "Twinkle Twinkle Little Stars"
• Presione C D E F G para reproducir la escala hacia arriba y hacia abajo
• Pulsa C D A B para reproducir "¡Oh Susanna!"
• Pulsa C C # A # B para reproducir "Frere Jacques / Brother John"

También te he facilitado la transcripción de las melodías que elijas a partir de la partitura de tu melodía.

Si está interesado en leer más sobre el código (¡y sé que lo está!), ¡Siga leyendo!

Repasemos rápidamente las partes principales del código. Puede consultar rápidamente el código de demostración aquí:https://github.com/protostax/ProtoStax_CapacitiveTouch_Piano_Demo/blob/master/ProtoStax_CapacitiveTouch_Piano_Demo.ino

El código se puede dividir en 3 partes:

• Obtener datos táctiles de MPR121 usando la biblioteca Adafruit_MRP121.
• Decidir qué hacer con los datos táctiles, es decir, tocar el tono correspondiente como un piano, o detectar toques múltiples y luego tocar el tintineo secreto, ambos usando la biblioteca de tonos incorporada.
• Programación de melodías, incluido cómo agregar sus propias melodías

Aquí hay un vistazo rápido a la parte táctil capacitiva del código. Como suele ser el caso, declara un objeto de la clase Adafruit_MPR121. En setup (), llama al método begin () para inicializarlo, y puede obtener los pads actualmente tocados en loop () usando el método cap.touched (). ¡Sencillo!

  Adafruit_MPR121 cap =Adafruit_MPR121 (); void setup () {... // La dirección predeterminada es 0x5A, si está vinculada a 3.3V es 0x5B // Si está vinculada a SDA es 0x5C y si SCL entonces 0x5D si ( ! cap.begin (0x5A)) {Serial.println ("MPR121 no encontrado, verifique el cableado?"); mientras (1); } ...} void loop () {// Obtiene los pads tocados actualmente currtouched =cap.touched ();}  

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

  // si * es * tocado y * no * tocado antes, ¡toque el tono correspondiente! if ((actual tocado &_BV (i)) &&! (último tocado &_BV (i))) {// Serial.print ("currtouched ="); Serial.print (actualizado); Serial.print ("lasttouched ="); Serial.print (último tocado); Serial.print (""); Serial.print (i); Serial.println ("tocado"); tono (TONE_PIN, escala [i]); } // si * fue * tocado y ahora * no *, y además, no se está presionando ningún botón, entonces detenga el tono // Esto permite transiciones suaves entre notas mientras desliza el dedo sobre las teclas // Esto también permite para sostener una nota determinada, tocando cualquier tecla y manteniéndola tocada; puede presionar otra tecla y la tocará, pero no dejará de tocarla // hasta que suelte la primera tecla, algo así como la ¡Sostenga el pedal del piano! if (! (actualizadas &_BV (i)) &&(últimamente tocadas &_BV (i)) &&! actualizadas) {// if (! (actualizadas &_BV (i)) &&(últimamente tocadas &_BV (i))) {/ / Serial.print ("currtouched ="); Serial.print (actualizado); Serial.print ("lasttouched ="); Serial.print (último tocado); Serial.print (""); Serial.print (i); Serial.println ("publicado"); noTone (TONE_PIN); }  

Manejamos múltiples toques de teclas especiales tocando la melodía correspondiente:

  // ¡Reproduce melodías si se presiona nuestra combinación 'secreta' de teclas! if (actual ==2193) {// C E G B playTune (melodía, MELODY_LENGTH (melodía), 2); // Reproduce Twinkle Twinkle Little Star} else if (currtouched ==181) {// C D E F G playTune (melody2, MELODY_LENGTH (melody2), 48); // Reproduce el deslizamiento de escala hacia arriba y hacia abajo} else if (actual tocado ==2565) {// C D A B playTune (melody3, MELODY_LENGTH (melody3), 1); // ¡Juega Oh Susanna! } else if (actual ==3075) {// C C # A # B playTune (melody4, MELODY_LENGTH (melody4), 1); // Reproduce Frere Jacques} else {...  

playTune () se usa para tocar una melodía determinada, que es una matriz de "Note" s

  void playTune (Nota * m, int mSize, int speedUp) {noTone (TONE_PIN); // Comience con una pizarra limpia para (int thisNote =0; thisNote  

Echemos un vistazo a una melodía:consta de una serie de notas. Cada nota tiene una frecuencia y una duración. =

  typedef struct Note {int frecuencia; duración de la flotación; } Nota; // Esta melodía reproduce todas las notas de la octava desde C hasta B y de regreso a CNote 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_AS 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_DE, NOTE_WHOLE}, {NOTE_CS, NOTE_WHOLE}, {NOTE_C, NOTE_WHOLE}};  

Aquí es donde las #defines en pitches.hy noteDurations.h son útiles. Puede utilizar estos en lugar de las frecuencias y duraciones reales. Por ejemplo, use NOTE_C para tocar un tono C y use NOTE_WHOLE para tocarlo como una nota completa (NOTE_HALF, NOTE_QUARTER, NOTE_EIGHTH son algunas otras duraciones de nota). También puede utilizar la macro DOTTED () para especificar una nota "punteada", como DOTTED (NOTE_QUARTER).

[Nota:una nota punteada es una nota cuya duración se extiende por otra nota de la mitad de su duración; por ejemplo, una nota media punteada equivale a 3/4 de una nota completa (1/2 nota más 1/2 de 1/2 nota). ]

¡Estos le permitirán tomar cualquier partitura y transcribirla a su matriz de melodías!

En la demostración, he transcrito "Twinkle Twinkle Little Star", "Frere Jacques / Brother John" y "¡Oh Susanna!" así que tienes algo con lo que jugar (¡¿sin juego de palabras ?! 😜):todas estas canciones caben en una octava, que es la restricción de nuestro teclado a la que traté de ceñirme. Por supuesto, cuando toca una melodía secreta, no está sujeto a este límite y puede usar varias octavas. "¡Oh Susanna!" también es un poco más complejo, ya que utiliza notas medias, negras y corcheas y también notas negras y medias "punteadas"; con suerte, esto le ayudará a tener una buena idea de cómo transcribir fácilmente otras melodías.

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

Paso 5:¡Llevándolo más lejos!

¡Aquí tienes algunas ideas para llevar el proyecto aún más lejos!

1. ¡Cree sus propios jingles / melodías (o transcriba los existentes) y asigne sus propias "Claves secretas" para activarlos!

2. ¡Agregue un segundo piezo para obtener sonidos polifónicos de 2 niveles! La biblioteca de tonos usa Timer2 para enviar una onda cuadrada al zumbador piezoeléctrico para reproducir un tono. El Arduino Uno tiene 3 temporizadores, aunque el temporizador 0 es especial y se usa para cosas como millis () y pwm. Eso todavía nos deja Timer1 para usar. La biblioteca NewTone es una reescritura más optimizada de la biblioteca de tonos, que usa Timer1. Por lo tanto, puede tener dos tonos al mismo tiempo, uno usando tono y el otro usando NewTone, por ejemplo.

3. Agregue uno o dos botones adicionales para agregar funcionalidad adicional, como presionar el botón para extender la octava a la más alta o más baja. ¡Al presionar estos botones junto con sus teclas táctiles capacitivas, puede tener un rango más amplio en su teclado!

¿Puedes pensar en algo más? ¡Escriba un comentario a continuación para hacérnoslo saber! 😊 ¡No dude en hacer cualquier pregunta que pueda tener! 😊

¡Feliz fabricación! 😊

Código

ProtoStax_CapacitiveTouch_Piano_Demo

Demostración para ProtoStax Piano con ProtoStax para Arduino Enclosure, Adafruit 12 x Capacitive Touch Shield para Arduino - MPR121, Piezo Buzzer y Arduino https://github.com/protostax/ProtoStax_CapacitiveTouch_Piano_Demo.git

Piezas y carcasas personalizadas

Plantilla para cortar teclas de piano para ProtoStax Capacitive Touch Piano y para perforar agujeros en la placa superior

Esquemas

Mini batalla contra jefes Programación de la serie Atmel AT89 a través de Arduino