Construire un piano tactile capacitif portable avec Arduino – Guide étape par étape

Composants et fournitures

Boîtier ProtoStax pour Arduino	×	1
Shield tactile capacitif 12x Adafruit pour Arduino - MPR121	×	1
Buzzer piézo Adafruit - PS1240	×	1
Arduino UNO	×	1
Ruban de cuivre avec adhésif conducteur	×	1
Kit fils de connexion, 22 AWG	×	1

À propos de ce projet

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

• un Arduino,
• un Shield tactile capacitif pour Arduino utilisant le MPR121,
• un buzzer piézo,
• du ruban 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 petit piano compact que vous pouvez emporter et jouer n'importe où, et programmer de nouveaux airs !

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

Attendez une minute ! Il y a 12 demi-tons dans une octave - Do, Do#, Ré, Ré#, Mi, Mi#, Fa, Sol, Sol#, La, La#, Si ! Parfait ! Eh bien, ce serait génial si le MPR121 gérait 13 entrées - cela nous aurait permis d'aller du Do au Do de l'octave supérieure, mais il y a encore beaucoup de mélodies possibles ! (et je propose aussi des suggestions ci-dessous pour étendre la gamme d'octaves)

De plus, vous pouvez également programmer vos propres séquences de touches ("Clés Secrètes" ou combinaisons de touches) pour jouer n'importe quelles mélodies aléatoires qui peuvent inclure autant d'octaves que vous le souhaitez (limité seulement par la capacité de votre oreille à entendre les notes, ou de votre piézo/haut-parleur à les jouer !).

Pour la sortie, j'utilise la bibliothèque tone d'Arduino pour jouer le son via un buzzer piézo. Vous pouvez aussi utiliser un haut-parleur - n'oubliez pas d'utiliser une résistance pour limiter le courant à ce que la broche de l'Arduino peut fournir !

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

Enfin vient le boîtier. Certains d'entre vous savent peut-être que j'ai créé un nouveau système de boîtier modulaire et empilable appelé ProtoStax. C'était une envie personnelle que je devais satisfaire - je voulais un boîtier qui supporte différentes étapes du prototypage, offrant protection et accès ouvert au début, avec la possibilité d'ajouter des parois latérales et le couvercle plus tard, mais aussi la possibilité d'empiler plusieurs unités côte à côte ou l'une sur l'autre, ayant ainsi la capacité 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 convient aux empreintes Uno/Leonardo ainsi qu'aux plus grandes Mega/Due – qui est aussi empilable et modulaire et a confortablement de la place pour les deux shields (avec quelques modifications mineures que je décrirai). Il est transparent et robuste et a aussi des pieds en caoutchouc pour le surélever légèrement et protéger la surface de votre table. La surface supérieure du boîtier agit aussi comme clavier pour votre piano tactile – c'est là que vous collerez votre ruban de cuivre conducteur ! À la fin, vous aurez un petit piano tactile sympa que vous pourrez facilement transporter, exposer et jouer ! 😊

Bon, commençons, voulez-vous ? 😊

Étape 1 - Monter 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 donne une protection tout en offrant un accès ouvert complet pour configurer et mettre en place l'Arduino et jouer avec. Quand 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 les pieds et autre matériel pour préparer le boîtier en Configuration Plateforme. 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éparer le shield MPR121 pour l'Arduino

J'ai coupé à la longueur 12 morceaux de fil toronné 22 AWG. Je les ai ensuite soudés sur le shield MPR121. Le shield Adafruit a deux grands trous pour chacune des 12 entrées pour pince crocodile. Entre ces deux trous se trouve un plus petit trou normal qui accueillera un fil 22 AWG.

Le shield MPR121 expose aussi toutes les broches via des trous à côté des connecteurs. J'ai aussi soudé un buzzer piézo PS1240, avec une patte insérée dans la broche 12 et l'autre à 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 de maintenir l'ordre plus tard lors de l'assemblage.

Étape 3 - Préparer le boîtier

Ensuite, nous devons préparer le boîtier. Nous commençons par insérer le shield dans l'Arduino monté sur la plaque de base. Nous insérons ensuite les éléments de renfort supérieurs et les parois latérales dans les fentes de mur.

J'ai pris le couvercle standard du boîtier ProtoStax pour Arduino et y ai ajouté 12 trous pour y insérer les fils des entrées du shield. J'ai utilisé une découpeuse laser pour couper les trous correspondant au modèle de touches de piano, mais vous pouvez tout aussi facilement utiliser une perceuse (assurez-vous juste d'utiliser du ruban de masquage sur la plaque acrylique avant de percer). Un petit trou de 1/8" devrait suffire.

J'insère ensuite soigneusement les fils du shield 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 d'insérer progressivement les fils numérotés (ils sont numérotés sur le shield) dans les trous de gauche à droite. J'ajoute ensuite les entretoises supérieures sous la plaque supérieure, et visse le couvercle pour terminer le boîtier.

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

Je découpe ensuite des morceaux d'un rouleau de cuivre avec adhésif conducteur en forme de touches de piano à partir du modèle (voir ci-dessous pour le modèle). Je décolle ensuite soigneusement le ruban de cuivre et le colle à leurs positions respectives sur la plaque supérieure du boîtier, en m'assurant que le ruban de cuivre colle sur le fil correspondant qui dépasse du trou.

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

À la fin, ça ressemble à ceci : (j'aurais pu faire un meilleur travail avec le ruban de cuivre, mais c'était ma première fois, donc j'espère m'améliorer dans la manipulation à 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éverser l'exemple de sketch, qui transforme votre création en piano tactile, et inclut des combinaisons de touches secrètes pour jouer quelques airs.

• Appuyez sur Do Mi Sol Si pour jouer "Twinkle Twinkle Little Stars"
• Appuyez sur Do Ré Mi Fa Sol pour jouer la gamme montante et descendante
• Appuyez sur Do Ré La Si pour jouer "Oh Susanna !"
• Appuyez sur Do Do# La# Si pour jouer "Frère Jacques"

Je l'ai aussi rendu facile pour vous de transcrire vos propres mélodies de choix depuis la partition.

Si vous êtes intéressé par la lecture du code (et je sais que vous l'êtes !), continuez !

Passons rapidement en revue les parties principales du code. Vous pouvez consulter rapidement 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 les données tactiles du MPR121 en utilisant la bibliothèque Adafruit_MRP121.
• Décider quoi faire avec les données tactiles - c'est-à-dire jouer la tonalité correspondante comme un piano, ou détecter les multi-touches et jouer l'air secret, les deux en utilisant la bibliothèque tone intégrée.
• Programmer des mélodies, y compris comment ajouter vos propres mélodies.

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() {
  ...
  // Adresse par défaut 0x5A, si relié à 3.3V c'est 0x5B
  // Si relié à SDA c'est 0x5C et si SCL alors 0x5D
  if (!cap.begin(0x5A)) {
    Serial.println("MPR121 not found, check wiring?");
    while (1);
  }
  ...
}
void loop() {
  // Obtenir 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 arrêter la tonalité quand le bouton n'est plus pressé :

// si elle *est* touchée et *n'était pas* touchée avant, jouer la tonalité correspondante !
if ((currtouched & _BV(i)) && !(lasttouched & _BV(i))) {
  // Serial.print("currtouched = ");
  Serial.print(currtouched);
  Serial.print(" lasttouched = ");
  Serial.print(lasttouched);
  Serial.print(" ");
  Serial.print(i);
  Serial.println(" touched");
  tone(TONE_PIN, scale[i]);
}
// si elle *était* touchée et maintenant *n'est plus*, et en plus, aucun bouton n'est pressé, alors arrêter la tonalité
// Cela permet des transitions douces entre les notes quand vous faites glisser votre doigt sur les touches
// Cela permet aussi la tenue d'une note donnée, en touchant n'importe quelle touche et en la maintenant touchée - vous pouvez appuyer sur une autre touche et elle jouera cette touche, mais n'arrêtera pas de jouer
// jusqu'à ce que vous relâchiez votre première touche - un peu comme la pédale de sustain du piano !
if (!(currtouched & _BV(i)) && (lasttouched & _BV(i)) && !currtouched) {
  // Serial.print("currtouched = ");
  Serial.print(currtouched);
  Serial.print(" lasttouched = ");
  Serial.print(lasttouched);
  Serial.print(" ");
  Serial.print(i);
  Serial.println(" released");
  noTone(TONE_PIN);
}

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

// Jouer des mélodies si notre combinaison 'secrète' de touches est pressée !
if (currtouched == 2193) { // Do Mi Sol Si
  playTune(melody, MELODY_LENGTH(melody), 2); // Jouer Twinkle Twinkle Little Star
} else if (currtouched == 181) { // Do Ré Mi Fa Sol
  playTune(melody2, MELODY_LENGTH(melody2), 48); // Jouer gamme montante/descendante
} else if (currtouched == 2565) { // Do Ré La Si
  playTune(melody3, MELODY_LENGTH(melody3), 1); // Jouer Oh Susanna !
} else if (currtouched == 3075) { // Do Do# La# Si
  playTune(melody4, MELODY_LENGTH(melody4), 1); // Jouer Frère Jacques
} else {
  ...

playTune() est utilisé pour jouer une mélodie donnée, qui est un tableau de "Note"s :

void playTune(Note *m, int mSize, int speedUp) {
  noTone(TONE_PIN); // Commencer avec une ardoise propre
  for (int thisNote = 0; thisNote < mSize; thisNote++) {
    // pour calculer la durée de la note, prendre une seconde multipliée par le type de note.
    // ex: noire = 1000.0 * 0.25, croche = 1000 * 1/8 (0.125), etc.
    // réduire la durée par le facteur speedup pour augmenter la vitesse de lecture
    // d'un montant approprié
    int noteDuration = 1000.0 * m[thisNote].duration / speedUp;
    tone(TONE_PIN, m[thisNote].frequency, noteDuration);
    // pour distinguer les notes, définir un temps minimum entre elles.
    // la durée de la note + 30% semble bien fonctionner :
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
    // arrêter la tonalité :
    noTone(TONE_PIN);
  }
  delay(100);
}

Regardons une mélodie - elle consiste en un tableau de Notes. Chaque Note a une fréquence et une durée.

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

// Cette mélodie joue toutes les notes de l'octave de Do jusqu'à Si et retour à 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}
};

C'est là que les #define dans pitches.h et noteDurations.h sont utiles. Vous pouvez les utiliser au lieu des fréquences et durées réelles. Par exemple, utilisez NOTE_C pour jouer un Do, et NOTE_WHOLE pour le jouer comme une noire (NOTE_HALF, NOTE_QUARTER, NOTE_EIGHTH sont d'autres durées). Vous pouvez aussi utiliser la macro DOTTED() pour spécifier une note "pointée" - comme DOTTED(NOTE_QUARTER).

[Note : Une note pointée est une note dont la durée est prolongée d'une autre note de la moitié de sa durée - par exemple, une noire pointée équivaut à 3/4 d'une ronde (1/2 note plus 1/2 de 1/2 note).]

Cela vous permettra de prendre n'importe quelle partition et de la transcrire dans votre tableau de mélodie !

Dans la démo, j'ai transcrit "Twinkle Twinkle Little Star", "Frère Jacques" et "Oh Susanna !" pour que vous ayez quelque chose avec quoi jouer (sans jeu de mots ! 😜) - toutes ces chansons tiennent dans une octave, qui est la restriction de notre clavier que j'ai essayé de respecter. Bien sûr, en jouant un air secret, vous n'êtes pas lié par cette limite et pouvez utiliser plusieurs octaves. "Oh Susanna !" est aussi un peu plus complexe, utilisant des noires, croches, doubles croches et aussi des noires et blanches pointées - j'espère que cela vous aidera à bien comprendre comment transcrire facilement d'autres airs.

Vérifions ça en action, voulez-vous ? 😊

Étape 5 - Aller plus loin !

Voici quelques idées pour aller encore plus loin avec le projet !

1. Créez vos propres airs/mélodies (ou transcrivez-en d'existants) et assignez vos propres "Clés Secrètes" pour les activer !

2. Ajoutez un deuxième piézo pour obtenir des sons polyphoniques à 2 niveaux ! La bibliothèque tone utilise le Timer2 pour envoyer une onde carrée au buzzer piézo pour jouer une tonalité. L'Arduino Uno a 3 timers, bien que le Timer 0 soit spécial et utilisé pour des choses comme millis() et PWM. Cela nous laisse encore le Timer1 à utiliser. La bibliothèque NewTone est une réécriture optimisée de la bibliothèque tone, qui utilise le Timer1. Vous pouvez ainsi avoir deux tonalités en même temps, l'une utilisant tone et l'autre utilisant NewTone, par exemple.

3. Ajoutez un bouton ou deux supplémentaires pour ajouter des fonctionnalités - comme utiliser l'appui du bouton pour étendre l'octave vers la supérieure ou l'inférieure. En appuyant sur ces boutons en conjonction avec vos touches tactiles capacitives, vous pouvez avoir une plus grande gamme sur votre clavier !

Pouvez-vous penser à d'autres idées ? Écrivez un commentaire ci-dessous pour nous le faire savoir ! 😊 N'hésitez pas à poser vos questions ! 😊

Bon bricolage ! 😊

Code

ProtoStax_CapacitiveTouch_Piano_Demo

Démo pour piano ProtoStax avec boîtier ProtoStax pour Arduino, Shield tactile capacitif 12x Adafruit MPR121, Buzzer piézo, et Arduino

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

Pièces personnalisées et boîtiers

Modèle pour découper les touches de piano pour le piano tactile capacitif ProtoStax et percer les trous dans la plaque supérieure

Schémas