Tragbares kapazitives Touch-Piano

Über dieses Projekt

In diesem Projekt erkläre ich, wie man mit

• ein Arduino,
• ein kapazitives Touch-Shield für Arduino mit dem MPR121,
• ein Piezo-Summer,
• Kupferfolienband mit leitfähigem Kleber (in Form von Klaviertasten geschnitten),

alles in einem durchsichtigen Acrylgehäuse (ProtoStax für Arduino) mit den kapazitiven Touch-Tasten auf der Oberseite eingeschlossen. Dies macht es zu einem schönen kompakten kleinen Klavier, mit dem Sie spielen und jammen und neue Melodien codieren können!

Für die kapazitive Berührungserkennung verwende ich das 12 x kapazitive Touch Shield für Arduino von Adafruit mit dem MPR121, gekoppelt mit der Adafruit_MPR121-Bibliothek, die es einfach macht, Berührungen auf bis zu 12 verschiedenen leitfähigen Oberflächen zu erkennen und darauf zu reagieren.

Warte eine Minute! Es gibt 12 Halbtöne in einer Oktave - C, C#, D, D#, E, E#, F, G, G#, A, A#, B! Perfekt! Nun, es wäre großartig gewesen, wenn der MPR121 13 Eingänge hätte - es hätte uns erlaubt, von C nach C der höheren Oktave zu gehen, aber es gibt immer noch viele Melodien zu haben! (Und ich biete unten auch Vorschläge an, wie Sie dieses Projekt durch Erweiterung des Oktavbereichs weiterführen können)

Darüber hinaus können Sie auch Ihre eigenen Anschlagsequenzen ("Secret Keys" oder Tastenkombinationen) programmieren, um beliebige Melodien zu spielen, die so viele Oktaven umfassen können, wie Sie möchten (begrenzt nur durch die Fähigkeit Ihres Gehörs, die Noten zu hören, oder Ihre Piezo/Lautsprecher zum Abspielen!).

Für die Ausgabe verwende ich die Tonbibliothek des Arduino, um den Ton über einen Piezo-Summer abzuspielen. Sie können auch einen Lautsprecher verwenden - denken Sie daran, einen Widerstand zu verwenden, um den Strom auf den zu beschränken, der vom Arduino-Pin bereitgestellt werden kann!

Für die Klaviertasten verwende ich Kupferfolienband mit Leitkleber. Es ist wichtig, es mit leitfähigem Klebstoff zu versehen, da Sie das Klebeband auf den Draht kleben, der mit der Abschirmung verbunden ist.

Als letztes kommt das Gehäuse. Einige von Ihnen wissen vielleicht, dass ich ein neues stapelbares, modulares Gehäusesystem namens ProtoStax entwickelt habe. Es war ein persönlicher Juckreiz, den ich kratzen musste - ich wollte ein Gehäuse, das verschiedene Phasen des Prototyping unterstützt, Schutz und offenen Zugang zu Beginn bietet, mit der Möglichkeit, später Seitenwände und die Oberseite hinzuzufügen, aber auch die Möglichkeit zum Stapeln hat mehrere Einheiten entweder nebeneinander oder übereinander, wodurch die Möglichkeit besteht, mit Prototyping-Anforderungen und dem Hinzufügen anderer Platinen und Komponenten zu erweitern.

In diesem Beispiel verwende ich ProtoStax für Arduino, ein durchsichtiges Acrylgehäuse für das Arduino – es passt sowohl auf den Uno/Leonardo-Footprint als auch auf den größeren Mega/Due-Footprint – das ist auch stapelbar und modular und bietet bequem Platz für die beiden Schilde (mit einigen geringfügigen Änderungen, die ich skizzieren werde). Es ist klar und robust und hat auch Gummifüße, um es leicht anzuheben und die Oberfläche Ihres Tisches zu schützen. Die Oberseite des Gehäuses dient auch als Tastatur für Ihr Touch-Piano - hier kleben Sie Ihr leitfähiges Kupferfolienband auf! Am Ende haben Sie ein raffiniertes kleines Touch-Piano, das Sie leicht herumtragen und anzeigen und mitjammen können!

Okay, fangen wir an, ja?

Schritt 1 - Montieren Sie das Arduino an der Gehäusegrundplatte

Montieren wir zuerst den Arduino (Uno in unserem Beispiel) auf der Grundplatte des Gehäuses. Dies bietet Schutz und bietet gleichzeitig vollen offenen Zugriff, um das Arduino zu konfigurieren und einzurichten und damit herumzuspielen. Wenn Sie bereit sind, es zu schließen, können Sie die Seitenwände und die obere Platte einfach hinzufügen und alles mit Schrauben befestigen.

Montieren Sie das Arduino auf der Grundplatte und fügen Sie Füße und andere Hardware hinzu, um das Gehäuse in der Plattformkonfiguration vorzubereiten . Sehen Sie sich die Schritte unten in der Diashow an - die Bildunterschrift ist nummeriert und enthält zusätzliche Erklärungen für jeden Schritt.

Hier sind alle Schritte als animiertes Gif:

Schritt 2 - Bereiten Sie das MPR121-Shield für das Arduino vor

Ich schneide 12 Stück 22 AWG Litzendraht auf Länge. Diese habe ich dann in das MPR121 Shield gelötet. Das Adafruit Shield hat für jeden der 12 Eingänge zwei große Löcher zum Greifen mit Krokodilklemmen. Zwischen diesen beiden Löchern befindet sich ein kleineres reguläres Loch, das einen 22 AWG-Draht aufnehmen kann.

Das MPR121 Shield legt auch alle Pins durch Löcher neben den Headern frei. Ich habe auch einen Piezo Buzzer PS1240 eingelötet, wobei ein Bein in Pin 12 und das andere an GND gesteckt ist.

Ich stellte sicher, dass das andere (freie) Ende jedes der Drähte abisoliert wurde. Ich habe für die 12 Eingänge ein sich wiederholendes Muster aus 6 verschiedenen Farben verwendet, um sie farblich zu kodieren, damit die Reihenfolge später beim Zusammenbau beibehalten werden kann.

Schritt 3 – Bereiten Sie das Gehäuse vor

Als nächstes müssen wir das Gehäuse vorbereiten. Wir beginnen mit dem Einsetzen des Schildes in das auf der Grundplatte montierte Arduino. Dann setzen wir die oberen Aussteifungselemente und die Seitenwände in die Wandschlitze ein.

Ich habe die Lageroberseite des ProtoStax für Arduino-Gehäuses genommen und 12 Löcher hinzugefügt, um die Drähte von den Schirmeingängen hindurch einzuführen. Ich habe einen Laserschneider verwendet, um die Löcher passend zur Klaviertastenschablone zu schneiden, aber Sie können genauso gut einen Bohrer verwenden (achten Sie nur darauf, dass Sie vor dem Bohren etwas Abdeckband auf der Acrylplatte verwenden). Ein kleines 1/8" Loch sollte ausreichen.

Ich stecke dann die Drähte der Abschirmung vorsichtig in die Löcher auf der oberen Platte ein - ich achte darauf, die Drähte von Loch 0 bis zum Loch ganz links einzuführen, und stecke fortlaufend nummerierte Drähte (sie sind auf der Abschirmung nummeriert) in die Löcher ein von links nach rechts. Ich füge dann die oberen Abstandshalter unter der oberen Platte hinzu und schraube die Schraubkappe ein, um das Gehäuse zu vervollständigen.

Als nächstes schiebe ich die Drähte zurück, bis nur noch die metallischen Teile außen ragen.

Dann schneide ich aus einer Rolle Kupferfolie mit leitfähigem Kleber Stücke in Form der Klaviertasten aus der Schablone aus (Schablone siehe unten). Dann schäle ich vorsichtig die Kupferfolie ab und klebe sie an ihren jeweiligen Positionen auf der oberen Platte des Gehäuses, wobei darauf geachtet wird, dass das Kupferband über den entsprechenden Draht, der aus dem Loch herausragt, klebt.

Hier ist die Schablone für die Klaviertasten und die Löcher. Sie sollten in der Lage sein, dies auf 8,5 x 11 Letter-Papier zu drucken und es in der richtigen Größe zu haben (lassen Sie es mich wissen, wenn Sie Probleme haben!)

Am Ende sieht es so aus:(Ich hätte es mit dem Kupferfolienband besser machen können, aber dies war das erste Mal, dass ich es benutzte, also werde ich hoffentlich in Zukunft besser damit umgehen! 😊)

Schritt 4 – Democode

Sie müssen zuerst die Adafruit_MPR121-Bibliothek installieren. Danach können Sie die Beispielskizze kompilieren und hochladen, die Ihre Kreation in ein Touch-Piano verwandelt und geheime Tastenkombinationen enthält, um einige Jingles zu spielen.

• Drücke C E G B, um "Twinkle Twinkle Little Stars" zu spielen
• Drücken Sie C D E F G, um die Skala nach oben oder unten abzuspielen
• Drücke C D A B, um "Oh Susanna!" zu spielen
• Drücken Sie C C# A# B, um "Frere Jacques/Bruder John" abzuspielen

Ich habe es Ihnen auch leicht gemacht, Ihre eigenen Melodien Ihrer Wahl aus der Partitur Ihrer Melodie zu transkribieren.

Wenn Sie mehr über den Code lesen möchten (und ich weiß, dass Sie es sind!), lesen Sie weiter!

Lassen Sie uns kurz die wichtigsten Teile des Codes durchgehen. Sie können hier schnell auf den Democode zugreifen - https://github.com/protostax/ProtoStax_CapacitiveTouch_Piano_Demo/blob/master/ProtoStax_CapacitiveTouch_Piano_Demo.ino

Der Code kann in 3 Teile geteilt werden:

• Abrufen von Berührungsdaten von MPR121 mithilfe der Adafruit_MRP121-Bibliothek.
• Entscheiden, was mit den Berührungsdaten zu tun ist - d.h. den entsprechenden Ton wie ein Klavier spielen oder Multi-Touches erkennen und dann den geheimen Jingle spielen, beides mit der eingebauten Tonbibliothek.
• Programmieren von Melodien, einschließlich des Hinzufügens eigener Melodien

Hier ist ein kurzer Blick auf den kapazitiven Touch-Teil des Codes. Normalerweise deklarieren Sie ein Objekt der Klasse Adafruit_MPR121. In setup() rufen Sie die Methode begin() auf, um sie zu initialisieren, und Sie können die aktuell berührten Pads in loop() mit der Methode cap.touched() abrufen. Einfach!

Adafruit_MPR121 cap =Adafruit_MPR121();void setup() {... // Die Standardadresse ist 0x5A, wenn sie an 3.3V gebunden ist, ist es 0x5B // Wenn sie an SDA gebunden ist, ist es 0x5C und wenn SCL dann 0x5D if ( !cap.begin(0x5A)) {Serial.println("MPR121 nicht gefunden, Verkabelung prüfen?"); während (1); }...}void loop() { // Hole die aktuell berührten Pads currtouched =cap.touched();} 

Mit den Touch-Daten können Sie auf eine Berührung reagieren, indem Sie den entsprechenden Ton spielen und den Ton stoppen, wenn die Taste nicht gedrückt wird:

 // Wenn es *berührt* ist und *nicht* zuvor berührt wurde, spiele den entsprechenden Ton! if ((currtouched &_BV(i)) &&! (lasttouched &_BV(i))) {//Serial.print("currtouched ="); Serial.print (currtouched); Serial.print ( " lasttouched ="); Serial.print (zuletzt berührt); Serial.print ( " "); Serial.print (i); Serial.println("berührt"); Ton (TONE_PIN, Skala[i]); } // wenn es *war* berührt wurde und jetzt *nicht* ist und zusätzlich keine Taste gedrückt wird, dann stoppen Sie den Ton // Dies ermöglicht sanfte Übergänge zwischen den Noten, wenn Sie mit dem Finger über die Tasten gleiten // Dies ermöglicht auch zum Aushalten einer bestimmten Note, indem Sie eine beliebige Taste berühren und gedrückt halten - Sie können eine andere Taste drücken und sie wird diese Taste spielen, aber nicht aufhören, sie zu spielen // bis Sie Ihre erste Taste loslassen - so ähnlich wie die Sustain-Pedal des Klaviers! 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 (zuletzt berührt); Serial.print ( " "); Serial.print (i); Serial.println("freigegeben"); kein Ton (TONE_PIN); } 

Wir handhaben Mehrfachberührungen von Sondertasten, indem wir die entsprechende Melodie spielen:

 // Spielen Sie Melodien, wenn unsere 'geheime' Tastenkombination gedrückt wird! if (currtouched ==2193) {// C E G B playTune (Melodie, MELODY_LENGTH (Melodie), 2); // Twinkle Twinkle Little Star spielen} else if (currtouched ==181) {// C D E F G playTune (melody2, MELODY_LENGTH (melody2), 48); // Tonleiter nach oben und unten schieben} else if (currtouched ==2565) {// C D A B playTune (melody3, MELODY_LENGTH (melody3), 1); // Spiel Oh Susanna! aufrechtzuerhalten. Sonst if (currtouched ==3075) {// C C # A # B playTune (melody4, MELODY_LENGTH (melody4), 1); // Frere Jacques spielen } else {... 

playTune() wird verwendet, um eine bestimmte Melodie zu spielen, die ein Array von "Note"s ist

void playTune(Note *m, int mSize, int speedUp) { noTone(TONE_PIN); // Beginnen Sie mit einer leeren Tafel für (int thisNote =0; thisNote  

typedef struct Hinweis { int frequency; Float-Dauer; } Notiz; // Diese Melodie spielt alle Noten der Oktave von C bis H und zurück bis 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_B, {_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 NOTE_WHOLE}, {NOTE_CS, NOTE_WHOLE}, {NOTE_C, NOTE_WHOLE}};