Piano tactile capacitif portable

À propos de ce projet

Dans ce projet, j'explique comment construire un piano tactile capacitif portable avec

• un Arduino,
• un écran tactile capacitif pour Arduino utilisant le MPR121,
• un buzzer piézo,
• ruban en feuille de cuivre avec adhésif conducteur (découpé en forme de touches de piano),

le tout enfermé dans un boîtier en acrylique transparent (ProtoStax pour Arduino) avec les touches tactiles capacitives collées sur sa surface supérieure. Cela en fait un joli petit piano compact avec lequel vous pouvez jouer, jouer et coder de nouveaux morceaux !

Pour la détection tactile capacitive, j'utilise le bouclier tactile capacitif 12 x d'Adafruit pour Arduino à l'aide du MPR121, couplé à la bibliothèque Adafruit_MPR121 qui facilite la détection et la réponse aux touchers sur jusqu'à 12 surfaces conductrices différentes.

Attends une minute! Il y a 12 demi-tons dans une octave - C, C#, D, D#, E, E#, F, G, G#, A, A#, B ! Parfait! Bon, ça aurait été super si le MPR121 gérait 13 entrées - ça nous aurait permis de passer du do au do de l'octave supérieure, mais il y a encore plein de morceaux à avoir ! (et j'offre également des suggestions ci-dessous sur la façon dont vous pouvez aller plus loin dans ce projet en élargissant la plage d'octave)

De plus, vous pouvez également programmer dans vos propres séquences tactiles ("Touches secrètes" ou combinaisons de touches) pour jouer des airs aléatoires qui peuvent inclure autant d'octaves que vous le souhaitez (limité uniquement par la puissance de votre oreille pour entendre les notes, ou votre piezo/haut-parleur pour le jouer !).

Pour la sortie, j'utilise la bibliothèque de sons de l'Arduino pour jouer le son via un buzzer Piezo. Vous pouvez également utiliser un haut-parleur - n'oubliez pas d'utiliser une résistance avec pour restreindre le courant à celui qui peut être fourni par la broche de l'Arduino !

Pour les touches du piano, j'utilise du ruban adhésif en cuivre avec un adhésif conducteur. Il est important de l'obtenir avec un adhésif conducteur car vous allez coller le ruban sur le fil connecté au blindage.

Vient enfin l'enclos. Certains d'entre vous savent peut-être que j'ai créé un nouveau système de boîtier modulaire empilable appelé ProtoStax. C'était une démangeaison personnelle que je devais gratter - je voulais un boîtier prenant en charge différentes étapes de prototypage, offrant une protection et un accès ouvert au démarrage, avec la possibilité d'ajouter des parois latérales et le dessus plus tard, mais également la possibilité de s'empiler plusieurs unités côte à côte ou superposées, ayant ainsi la possibilité de s'étendre avec les besoins de prototypage et l'ajout d'autres cartes et composants.

Dans cet exemple, j'utilise ProtoStax pour Arduino, un boîtier en acrylique transparent pour l'Arduino -- il s'adapte à la fois à l'empreinte Uno/Leonardo ainsi qu'à l'empreinte Mega/Due plus grande -- qui est également empilable et modulaire et a de la place confortablement pour les deux Boucliers (avec quelques modifications mineures, que je vais décrire). Il est clair et robuste et possède également des pieds en caoutchouc pour le surélever légèrement et protéger la surface de votre table. La surface supérieure de l'enceinte sert également de clavier pour votre piano tactile - c'est là que vous collerez votre ruban conducteur en feuille de cuivre ! À la fin, vous aurez un chouette petit piano tactile que vous pourrez facilement transporter et exposer et jouer avec !

Ok, commençons, voulez-vous ?

Étape 1 - Montez l'Arduino sur la plaque de base du boîtier

Montons d'abord l'Arduino (Uno dans notre exemple) sur la plaque de base du boîtier. Cela lui confère une protection tout en lui offrant un accès ouvert complet pour configurer et configurer l'Arduino et jouer avec. Lorsque vous êtes prêt à le fermer, il est facile d'ajouter les parois latérales et la plaque supérieure et de tout fixer avec des vis.

Montez l'Arduino sur la plaque de base et ajoutez des pieds et d'autres éléments matériels pour préparer le boîtier dans la Configuration de la plate-forme . Voir les étapes ci-dessous dans le diaporama - la légende de chaque image est numérotée et donne des explications supplémentaires pour chaque étape.

Voici toutes les étapes sous forme de gif animé :

Étape 2 - Préparez le Shield MPR121 pour l'Arduino

J'ai coupé à la longueur 12 morceaux de fil toronné 22 AWG. Je les ai ensuite soudés dans le bouclier MPR121. Le bouclier Adafruit a deux grands trous pour chacune des 12 entrées pour la préhension avec des pinces crocodiles. Entre ces deux trous se trouve un trou régulier plus petit qui pourra accueillir un fil de 22 AWG.

Le bouclier MPR121 expose également toutes les broches via des trous à côté des en-têtes. J'ai également soudé un Piezo Buzzer PS1240, avec une patte insérée dans la broche 12 et l'autre sur GND.

Je me suis assuré de dénuder l'autre extrémité (libre) de chacun des fils. J'ai utilisé un motif répétitif de 6 couleurs différentes pour les 12 entrées, pour les coder par couleur, afin que l'ordre puisse être maintenu plus tard lors de l'assemblage.

Étape 3 - Préparez le boîtier

Ensuite, nous devons préparer l'enceinte. Nous commençons par insérer le blindage dans l'Arduino monté sur la plaque de base. Nous insérons ensuite les éléments de contreventement supérieurs et les parois latérales dans les fentes murales.

J'ai pris le dessus du boîtier ProtoStax pour Arduino et lui ai ajouté 12 trous pour y insérer les fils des entrées de blindage. J'ai utilisé un cutter laser pour découper les trous correspondant au gabarit des touches du piano, mais vous pouvez tout aussi facilement utiliser une perceuse (assurez-vous simplement d'utiliser du ruban adhésif sur la plaque acrylique avant de percer). Un petit trou de 1/8" devrait suffire.

J'insère ensuite soigneusement les fils du blindage dans les trous de la plaque supérieure - je m'assure d'insérer le fil du trou 0 dans le trou le plus à gauche, et insère progressivement les fils numérotés (ils sont numérotés sur le blindage) dans les trous de gauche à droite. J'ajoute ensuite les entretoises supérieures sous la plaque supérieure et visser le bouchon à vis pour terminer le boîtier.

Ensuite, je repousse les fils jusqu'à ce que seules les parties métalliques dépassent à l'extérieur.

J'ai ensuite découpé des morceaux d'un rouleau de feuille de cuivre avec adhésif conducteur en forme de touches de piano à partir du modèle (voir ci-dessous pour le modèle). J'ai ensuite soigneusement pelé la feuille de cuivre et je les ai collées à leurs positions respectives sur la plaque supérieure du boîtier, en veillant à ce que le ruban de cuivre colle sur le fil correspondant dépassant du trou.

Voici le gabarit pour les touches du piano et les trous. Vous devriez pouvoir l'imprimer sur du papier Letter 8.5x11 et l'avoir à la bonne taille (faites-moi savoir si vous rencontrez des problèmes !)

Au final, cela ressemble à ceci :(J'aurais pu faire un meilleur travail avec le ruban adhésif en cuivre, mais c'était la première fois que je l'utilisais, alors j'espère que je m'améliorerai à l'avenir ! 😊)

Étape 4 - Code de démonstration

Vous devrez d'abord installer la bibliothèque Adafruit_MPR121. Après cela, vous pouvez compiler et télécharger l'exemple de croquis, qui transforme votre création en piano tactile et inclut des combinaisons de touches secrètes pour jouer des jingles.

• Appuyez sur C E G B pour jouer à "Twinkle Twinkle Little Stars"
• Appuyez sur C D E F G pour jouer l'échelle vers le haut et vers le bas
• Appuyez sur C D A B pour jouer à "Oh Susanna !"
• Appuyez sur C C# A# B pour jouer "Frère Jacques/Frère Jean"

Je vous ai également facilité la transcription des morceaux de votre choix à partir de la partition de votre morceau.

Si vous souhaitez en savoir plus sur le code (et je sais que vous l'êtes !), lisez la suite !

Passons rapidement en revue les principales parties du code. Vous pouvez rapidement référencer le code de démonstration ici - https://github.com/protostax/ProtoStax_CapacitiveTouch_Piano_Demo/blob/master/ProtoStax_CapacitiveTouch_Piano_Demo.ino

Le code peut être divisé en 3 parties :

• Obtenir des données tactiles à partir du MPR121 à l'aide de la bibliothèque Adafruit_MRP121.
• Décider quoi faire avec les données tactiles - c'est-à-dire jouer le son correspondant comme un piano, ou détecter les multi-touches, puis jouer le jingle secret, les deux à l'aide de la bibliothèque de sons intégrée.
• Programmer des morceaux, y compris comment ajouter vos propres morceaux

Voici un aperçu rapide de la partie tactile capacitive du code. Comme c'est généralement le cas, vous déclarez un objet de la classe Adafruit_MPR121. Dans setup(), vous appelez la méthode begin() pour l'initialiser, et vous pouvez obtenir les pads actuellement touchés dans loop() en utilisant la méthode cap.touched(). Simple !

Adafruit_MPR121 cap =Adafruit_MPR121();void setup() {... // L'adresse par défaut est 0x5A, si elle est liée à 3.3V c'est 0x5B // Si liée à SDA c'est 0x5C et si SCL alors 0x5D si ( !cap.begin(0x5A)) { Serial.println("MPR121 introuvable, vérifier le câblage ?"); tandis que (1) ; }...}void loop() { // Récupère les pads actuellement touchés currtouched =cap.touched();} 

Avec les données tactiles, vous pouvez répondre à une touche en jouant la tonalité correspondante et en arrêtant la tonalité lorsque le bouton n'est pas enfoncé :

 // s'il *est* touché et *n'a pas* touché avant, jouez le ton correspondant ! if ((currtouched &_BV(i)) &&!(lasttouched &_BV(i)) ) { // Serial.print("currtouched ="); Serial.print(currtouched); Serial.print(" lasttouched ="); Serial.print (dernière touche); Serial.print(" "); Serial.print(i); Serial.println("touché"); ton(TONE_PIN, échelle[i]); } // s'il *a été* touché et maintenant *n'est pas*, et en plus, aucun bouton n'est enfoncé, alors arrêtez la tonalité // Cela permet des transitions en douceur entre les notes lorsque vous faites glisser votre doigt sur les touches // Cela permet également pour le maintien d'une note donnée, en touchant n'importe quelle touche et en la maintenant enfoncée - vous pouvez appuyer sur une autre touche et elle jouera cette touche, mais n'arrêtera pas de la jouer // tant que vous n'aurez pas relâché votre première touche - un peu comme le pédale de sustain du piano ! if (!(currtouched &_BV(i)) &&(lasttouched &_BV(i)) &&!currtouched) { //if (!(currtouched &_BV(i)) &&(lasttouched &_BV(i))) { / / Serial.print("currtouched ="); Serial.print(currtouched); Serial.print(" lasttouched ="); Serial.print (dernière touche); Serial.print(" "); Serial.print(i); Serial.println("publié"); noTone(TONE_PIN); } 

Nous gérons les multi-touches de touches spéciales en jouant la mélodie correspondante :

 // Joue des morceaux si notre combinaison 'secrète' de touches est enfoncée ! if (currtouched ==2193) { // C E G B playTune(melody, MELODY_LENGTH(melody), 2); // Joue Twinkle Twinkle Little Star } else if (currtouched ==181) { // C D E F G playTune(melody2, MELODY_LENGTH(melody2), 48); // Lecture de l'échelle de haut en bas } else if (currtouched ==2565) { // C D A B playTune(melody3, MELODY_LENGTH(melody3), 1); // Joue à Oh Susanna ! } else if (currtouched ==3075) { // C C# A# B playTune(melody4, MELODY_LENGTH(melody4), 1); // Joue Frère Jacques } else {... 

playTune() est utilisé pour jouer une mélodie, qui est un tableau de "Notes"

void playTune(Note *m, int mSize, int speedUp) { noTone(TONE_PIN); // Commencez avec une table rase pour (int thisNote =0; thisNote  

typedef struct Remarque { int fréquence; durée flottante ; } Noter; // Cette mélodie joue toutes les notes de l'octave de C jusqu'à B et redescend jusqu'à 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_WHOLE}, {NOTE_A, NOTE_WHOLE}, {NOTE_AS, NOTE_WHOLE}, {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, NOTE_WHOLE}, {NOTE_CS, NOTE_WHOLE}, {NOTE_C, NOTE_WHOLE}} ;