Draagbare capacitieve aanraakpiano

Over dit project

In dit project leg ik uit hoe je een draagbare capacitive touch piano bouwt met

• een Arduino,
• een Capacitive Touch Shield voor Arduino met behulp van de MPR121,
• een piëzo-zoemer,
• koperfolietape met geleidende lijm (gesneden in de vorm van pianotoetsen),

allemaal ingesloten in een heldere acrylbehuizing (ProtoStax voor Arduino) met de capacitieve aanraaktoetsen op het bovenoppervlak. Dit maakt het een mooie compacte kleine piano die je kunt uitvoeren en mee kunt jammen en nieuwe deuntjes kunt coderen!

Voor de capacitieve aanraakdetectie gebruik ik Adafruit's 12 x Capacitive Touch Shield voor Arduino met behulp van de MPR121, in combinatie met de Adafruit_MPR121-bibliotheek die het gemakkelijk maakt om aanrakingen op maximaal 12 verschillende geleidende oppervlakken te detecteren en erop te reageren.

Wacht even! Er zijn 12 halve tonen in een octaaf - C, C#, D, D#, E, E#, F, G, G#, A, A#, B! Perfect! Nou, het zou geweldig zijn geweest als de MPR121 13 ingangen zou hebben verwerkt - het zou ons in staat hebben gesteld om van C naar C van het hogere octaaf te gaan, maar er zijn nog steeds genoeg deuntjes te krijgen! (en ik bied hieronder ook suggesties voor hoe je dit project verder kunt brengen door het octaafbereik uit te breiden)

Bovendien kunt u ook uw eigen aanslagreeksen ("Geheime toetsen" of toetscombinaties) programmeren om willekeurige melodieën te spelen die zoveel octaven kunnen bevatten als u wilt (alleen beperkt door de kracht van uw oor om de noten te horen, of uw piëzo/luidspreker om het af te spelen!).

Voor de uitvoer gebruik ik de toonbibliotheek van de Arduino om het geluid via een piëzo-zoemer af te spelen. Je kunt ook een luidspreker gebruiken - vergeet niet om er een weerstand bij te gebruiken om de stroom te beperken tot wat kan worden geleverd door de Arduino-pin!

Voor de pianotoetsen gebruik ik koperfolietape met geleidende lijm. Het is belangrijk om het met geleidende lijm te krijgen, omdat u de tape op de draad gaat plakken die op het schild is aangesloten.

Als laatste komt de behuizing. Sommigen van jullie weten misschien dat ik een nieuw stapelbaar, modulair behuizingssysteem heb gemaakt met de naam ProtoStax. Het was een persoonlijke jeuk dat ik moest krabben - ik wilde een behuizing die verschillende stadia van prototyping ondersteunde, bescherming en open toegang bood bij het begin, met de mogelijkheid om later zijwanden en de bovenkant toe te voegen, maar ook de mogelijkheid had om te stapelen meerdere eenheden naast elkaar of boven elkaar, waardoor ze de mogelijkheid hebben om uit te breiden met prototyping-behoeften en de toevoeging van andere boards en componenten.

In dit voorbeeld gebruik ik ProtoStax voor Arduino, een heldere acrylbehuizing voor de Arduino - hij past zowel op de Uno/Leonardo-voetafdruk als op de grotere Mega/Due-voetafdruk - die ook stapelbaar en modulair is en comfortabel ruimte biedt voor de twee Schilden (met enkele kleine aanpassingen, die ik zal schetsen). Het is helder en stevig en heeft ook rubberen voetjes om het iets te verhogen en het oppervlak van uw tafel te beschermen. Het bovenoppervlak van de behuizing fungeert ook als het toetsenbord voor uw touch-piano - hier plakt u uw geleidende koperfolietape op! Aan het einde heb je een handige kleine piano die je gemakkelijk mee kunt nemen en kunt laten zien en mee kunt jammen!

Oké, laten we beginnen, zullen we?

Stap 1 - Monteer de Arduino op de grondplaat van de behuizing

Laten we eerst de Arduino (Uno in ons voorbeeld) op de grondplaat van de behuizing monteren. Dit geeft het bescherming terwijl het volledige open toegang biedt om de Arduino te configureren en in te stellen en ermee te spelen. Wanneer u klaar bent om het te sluiten, is het eenvoudig om de zijwanden en de bovenplaat toe te voegen en alles vast te zetten met schroeven.

Monteer de Arduino op de basisplaat en voeg voetjes en andere hardware toe om de behuizing voor te bereiden in Platformconfiguratie . Zie onderstaande stappen in de diavoorstelling - het bijschrift voor elke afbeelding is genummerd en geeft extra uitleg voor elke stap.

Hier zijn alle stappen als een geanimeerde gif:

Stap 2 - Bereid het MPR121-schild voor op de Arduino

Ik heb 12 stukken 22 AWG gestrande draad op lengte gesneden. Deze heb ik vervolgens in het MPR121 Shield gesoldeerd. Het Adafruit Shield heeft twee grote gaten voor elk van de 12 ingangen voor het vastgrijpen met krokodillenklemmen. Tussen deze twee gaten bevindt zich een kleinere, reguliere die plaats biedt aan een 22 AWG-draad.

Het MPR121-schild stelt ook alle pinnen bloot via gaten naast de headers. Ik heb ook een piëzo-zoemer PS1240 gesoldeerd, met een been in pin 12 en de andere op GND.

Ik zorgde ervoor dat ik het andere (vrije) uiteinde van elk van de draden stripte. Ik gebruikte een herhalend patroon van 6 verschillende kleuren voor de 12 ingangen, om ze te kleurcoderen, zodat de volgorde later kon worden gehandhaafd bij het monteren.

Stap 3 - Bereid de behuizing voor

Vervolgens moeten we de behuizing voorbereiden. We beginnen met het plaatsen van het schild in de Arduino die op de basisplaat is gemonteerd. Vervolgens plaatsen we de bovenste verstevigingselementen en de zijwanden in de muursleuven.

Ik heb de standaard bovenkant van de ProtoStax voor Arduino-behuizing genomen en er 12 gaten aan toegevoegd om de draden van de schildingangen doorheen te steken. Ik heb een lasersnijder gebruikt om de gaten te snijden die overeenkomen met de sjabloon van de pianosleutel, maar je kunt net zo goed een boor gebruiken (gebruik wel wat plakband op de acrylplaat voordat je gaat boren). Een klein gaatje van 1/8" zou voldoende moeten zijn.

Ik steek dan voorzichtig de draden van het schild in de gaten op de bovenplaat - ik zorg ervoor dat ik de draad van gat 0 naar het meest linkse gat steek en steek geleidelijk genummerde draden (ze zijn genummerd op het schild) in de gaten van links naar rechts. Ik voeg dan de bovenste afstandhouders onder de bovenplaat toe en schroef de schroefdop erin om de behuizing af te ronden.

Vervolgens duw ik de draden terug totdat alleen de metalen delen naar buiten steken.

Vervolgens heb ik stukken uit een rol koperfolie met geleidende lijm in de vorm van de pianotoetsen uit de sjabloon gesneden (zie hieronder voor sjabloon). Ik pel dan voorzichtig de koperfolie af en plak ze op hun respectieve posities op de bovenplaat van de behuizing, waarbij ik ervoor zorg dat de kopertape over de corresponderende draad plakt die uit het gat steekt.

Hier is de sjabloon voor de pianotoetsen en de gaten. U zou dit op 8.5x11 Letter-papier moeten kunnen afdrukken en het juiste formaat hebben (laat het me weten als u problemen ondervindt!)

Uiteindelijk ziet het er zo uit:(ik had het beter kunnen doen met de koperfolietape, maar dit was de eerste keer dat ik het gebruikte, dus hopelijk zal ik er in de toekomst beter mee omgaan! 😊)

Stap 4 - Democode

U moet eerst de Adafruit_MPR121-bibliotheek installeren. Daarna kun je de voorbeeldschets compileren en uploaden, die je creatie in touch piano verandert, en geheime toetsencombinaties bevat om wat jingles te spelen.

• Druk op C E G B om "Twinkle Twinkle Little Stars" te spelen
• Druk op C D E F G om de schaal omhoog en omlaag te spelen
• Druk op C D A B om "Oh Susanna!" te spelen
• Druk op C C# A# B om "Frere Jacques/Brother John" te spelen

Ik heb het je ook gemakkelijk gemaakt om je eigen deuntjes naar keuze uit de partituur van je deuntje te transcriberen.

Als je meer wilt lezen over de code (en ik weet dat je dat bent!), lees dan verder!

Laten we snel de belangrijkste delen van de code doornemen. U kunt hier snel naar de democode verwijzen - https://github.com/protostax/ProtoStax_CapacitiveTouch_Piano_Demo/blob/master/ProtoStax_CapacitiveTouch_Piano_Demo.ino

De code kan in 3 delen worden opgesplitst:

• Aanraakgegevens ophalen van MPR121 met behulp van de Adafruit_MRP121-bibliotheek.
• Beslissen wat te doen met de aanslaggegevens - d.w.z. speel de corresponderende toon als een piano, of detecteer multi-touches en speel dan de geheime jingle, beide met behulp van de ingebouwde toonbibliotheek.
• Deuntjes programmeren, inclusief hoe u uw eigen deuntjes kunt toevoegen

Hier is een korte blik op het capacitieve aanraakgedeelte van de code. Zoals meestal het geval is, declareert u een object van de klasse Adafruit_MPR121. In setup() roept u de methode begin() aan om deze te initialiseren, en u kunt de momenteel aangeraakte pads in loop() krijgen met de methode cap.touched() . Simpel!

Adafruit_MPR121 cap =Adafruit_MPR121();void setup() {... // Standaardadres is 0x5A, indien gekoppeld aan 3,3V zijn 0x5B // Indien gekoppeld aan SDA zijn 0x5C en indien SCL dan 0x5D indien ( !cap.begin(0x5A)) { Serial.println("MPR121 niet gevonden, controleer de bedrading?"); terwijl (1); }...}void loop() { // Haal de momenteel aangeraakte pads op currtouched =cap.touched();} 

Met de aanraakgegevens kunt u op een aanraking reageren door de bijbehorende toon af te spelen en de toon te stoppen wanneer de knop niet wordt ingedrukt:

 // als het *is* aangeraakt en *niet* eerder is aangeraakt, speel dan de bijbehorende toon! if ((currtouched &_BV(i)) &&!(lasttouched &_BV(i))) { // Serial.print("currtouched ="); Serial.print (currtouched); Serial.print(" lasttouched ="); Serial.print (laatst aangeraakt); Serieel.print(" "); Serial.print(i); Serial.println ("aangeraakt"); toon (TONE_PIN, schaal [i]); } // als het *was* aangeraakt en nu *niet*, en bovendien wordt er geen knop ingedrukt, stop dan de toon // Dit zorgt voor vloeiende overgangen tussen noten terwijl je met je vinger over de toetsen schuift // Dit maakt het ook mogelijk voor het aanhouden van een bepaalde noot, door een toets aan te raken en ingedrukt te houden - je kunt een andere toets indrukken en hij zal die toets spelen, maar zal niet stoppen met spelen // totdat je je eerste toets loslaat - een beetje zoals de sustainpedaal van de 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 (laatst aangeraakt); Serieel.print(" "); Serial.print(i); Serial.println(" vrijgegeven"); geen toon (TONE_PIN); } 

We verwerken meerdere aanslagen van speciale toetsen door het bijbehorende deuntje te spelen:

 // Speel deuntjes als onze 'geheime' toetsencombinatie wordt ingedrukt! if (currtouched ==2193) { // C E G B playTune (melodie, MELODY_LENGTH (melodie), 2); // Speel Twinkle Twinkle Little Star } else if (currtouched ==181) { // C D E F G playTune (melody2, MELODY_LENGTH (melody2), 48); // Speel schaalschuif op en neer } else if (currtouched ==2565) { // C D A B playTune (melody3, MELODY_LENGTH (melody3), 1); // Speel Oh Susanna! } else if (currtouched ==3075) {// C C# A# B playTune(melody4, MELODY_LENGTH(melody4), 1); // Speel Frere Jacques } else {... 

playTune() wordt gebruikt om een ​​geef deuntje te spelen, wat een reeks "Note"s is

void playTune(Opmerking *m, int mSize, int speedUp) { noTone(TONE_PIN); // Begin met een schone lei voor (int thisNote =0; thisNote  

Laten we eens naar een melodie kijken - deze bestaat uit een reeks noten. Elke noot heeft een frequentie en een duur. =

typedef struct Opmerking { int frequentie; vlotterduur; } Opmerking; // Deze melodie speelt alle noten van het octaaf van C tot B en terug naar 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_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}, {NOWHOLE_DS, OPMERKING_DS, NOTE_WHOLE}, {NOTE_CS, NOTE_WHOLE}, {NOTE_C, NOTE_WHOLE}}; 

Dit is waar de #defines in pitches.h en noteDurations.h van pas komen. U kunt deze gebruiken in plaats van de werkelijke frequenties en duur. Gebruik bijvoorbeeld NOTE_C om een ​​C-toon te spelen, en gebruik NOTE_WHOLE om het als een hele noot te spelen (NOTE_HALF, NOTE_QUARTER, NOTE_EIGHTH zijn enkele andere nootduur). U kunt ook de macro DOTTED() gebruiken om een ​​"gestippelde" notitie op te geven, zoals DOTTED(NOTE_QUARTER).

[Opmerking:een gestippelde noot is een noot waarvan de duur wordt verlengd met een andere noot van de helft van de duur - een gestippelde halve noot is bijvoorbeeld gelijk aan 3/4 van een hele noot (1/2 noot plus 1/2 van 1/2 noot). ]

Hiermee kun je elke bladmuziek nemen en die naar je melodiearray transcriberen!

In de demo heb ik "Twinkle Twinkle Little Star", "Frere Jacques/Brother John" en "Oh Susanna!" dus je hebt iets om mee te spelen (geen woordspeling bedoeld?! ) - al deze nummers passen binnen één octaaf, wat de beperking van ons toetsenbord is waar ik me aan probeerde te houden. Bij het spelen van een geheim deuntje ben je natuurlijk niet aan deze limiet gebonden en kun je meerdere octaven gebruiken. "O Suzanna!" is ook een beetje ingewikkelder, met gebruik van halve, kwart- en achtste noten en ook "gestippelde" kwart- en halve noten - hopelijk zal dit je helpen een goed idee te krijgen hoe je andere melodieën gemakkelijk kunt transcriberen.

Laten we het in actie zien, zullen we?

Stap 5 - Verder gaan!

Hier zijn enkele ideeën om het project nog verder te brengen!

1. Maak je eigen jingles/melodieën (of transcribeer bestaande) en wijs je eigen "Geheime Sleutels" toe om ze te activeren!

2. Voeg een tweede piëzo toe om polyfone klanken van 2 niveaus te krijgen! De toonbibliotheek gebruikt Timer2 om een ​​blokgolf naar de piëzo-zoemer te sturen om een ​​toon af te spelen. De Arduino Uno heeft 3 timers, hoewel Timer 0 speciaal is en wordt gebruikt voor zaken als millis() en pwm. Dat laat ons nog steeds Timer1 te gebruiken. De NewTone-bibliotheek is een meer geoptimaliseerde herschrijving van de toonbibliotheek, die Timer1 gebruikt. Je kunt dus twee tonen tegelijk hebben, de ene met toon en de andere met bijvoorbeeld NewTone.

3. Voeg een of twee extra knoppen toe om extra functionaliteit toe te voegen - zoals het gebruik van de knop om het octaaf te verhogen naar een hoger of lager octaaf. Door deze knoppen samen met uw capacitieve aanraaktoetsen in te drukken, krijgt u een groter bereik op uw toetsenbord!

Kun je er nog meer bedenken? Schrijf hieronder een reactie om het ons te laten weten! 😊 Stel gerust al je vragen!

Veel plezier met maken!

Code

ProtoStax_CapacitiveTouch_Piano_Demo

Demo voor ProtoStax Piano met ProtoStax voor Arduino-behuizing, Adafruit 12 x Capacitive Touch Shield voor Arduino - MPR121, Piezo Buzzer en Arduino https://github.com/protostax/ProtoStax_CapacitiveTouch_Piano_Demo.git

Aangepaste onderdelen en behuizingen

Sjabloon voor het snijden van pianotoetsen voor ProtoStax Capacitive Touch Piano en voor het boren van gaten in de bovenplaat

Schema's