Bouw een Draagbare Capacitieve Touch-piano met Arduino – Stap-voor-stap Handleiding

Onderdelen en benodigdheden

ProtoStax Behuizing voor Arduino	×	1
Adafruit 12x Capacitive Touch Shield voor Arduino - MPR121	×	1
Adafruit Piezo Buzzer - PS1240	×	1
Arduino UNO	×	1
Koperfolieband met geleidende lijm	×	1
Hook-up Draad Kit, 22 AWG	×	1

Over dit project

In dit project leg ik uit hoe je een draagbare capacitieve touch-piano bouwt met:

• een Arduino,
• een Capacitive Touch Shield voor Arduino met de MPR121,
• een piezo-buzzer,
• koperfolieband met geleidende lijm (geknipt in de vorm van pianotoetsen),

alles ingesloten in een heldere acrylbehuizing (ProtoStax voor Arduino) met de capacitieve toetsen op de bovenkant geplakt. Dit maakt een nette, compacte piano die je mee kunt nemen en waarop je kunt jammen en nieuwe tunes kunt programmeren!

Voor de capacitieve touch-sensing gebruik ik de Adafruit 12x Capacitive Touch Shield voor Arduino met de MPR121, gecombineerd met de Adafruit_MPR121-bibliotheek die het makkelijk maakt om aanrakingen op tot 12 verschillende geleidende oppervlakken te detecteren en te beantwoorden.

Wacht even! Er zijn 12 halvetoontjes in een octaaf - C, Cis, D, Dis, E, F, Fis, G, Gis, A, Bes, B! Perfect! Het zou geweldig zijn geweest als de MPR121 13 ingangen had – dan kon je van C naar C van de hogere octaaf gaan, maar er zijn nog steeds genoeg tunes mogelijk! (En ik geef hieronder suggesties hoe je het project kunt uitbreiden met een groter octaafbereik).

Daarnaast kun je ook je eigen aanraaksequenties ("Geheime Toetsen" of toetsencombinaties) programmeren om willekeurige tunes af te spelen die zoveel octaven kunnen bevatten als je wilt (beperkt alleen door je gehoor of de piezo/speaker).

Voor de output gebruik ik de Arduino-tone-bibliotheek om het geluid af te spelen via een piezo-buzzer. Je kunt ook een speaker gebruiken – onthoud dan wel een weerstand te gebruiken om de stroom te beperken tot wat de Arduino-pin kan leveren!

Voor de pianotoetsen gebruik ik koperfolieband met geleidende lijm. Het is belangrijk om deze met geleidende lijm te krijgen, want je gaat de band op de draad plakken die verbonden is met de shield.

Tot slot de behuizing. Sommige van jullie weten misschien dat ik een nieuw stapelbaar, modulair behuizingssysteem heb gemaakt genaamd ProtoStax. Het was een persoonlijke "jeuk" die ik moest kwijtraken – ik wilde een behuizing die verschillende fasen van prototypen ondersteunt, bescherming en open toegang biedt bij het begin, met de mogelijkheid om later zijwanden en de bovenkant toe te voegen, maar ook de mogelijkheid om meerdere units naast elkaar of op elkaar te stapelen, zodat het kan uitbreiden met prototyping-behoeftes en de toevoeging van andere borden en componenten.

In dit voorbeeld gebruik ik ProtoStax voor Arduino, een heldere acrylbehuizing voor de Arduino – die past op zowel de Uno/Leonardo- als de grotere Mega/Due-footprint – die ook stapelbaar en modulair is en comfortabel ruimte biedt voor de twee shields (met enkele kleine aanpassingen die ik zal uitleggen). Het is helder, stevig en heeft rubberen voertjes om het iets op te heffen en het oppervlak van je tafel te beschermen. De bovenkant van de behuizing fungeert ook als het toetsenblad voor je touch-piano – dit is waar je je geleidende koperfolieband gaat plakken! Aan het eind heb je een handige kleine touch-piano die je gemakkelijk mee kunt nemen en waarop je kunt jammen! 😊

Ok, laten we beginnen! 😊

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

Laten we eerst de Arduino (Uno in ons voorbeeld) monteren op de basisplaat van de behuizing. Dit geeft bescherming terwijl het volle open toegang biedt om de Arduino te configureren en ermee te experimenteren. Wanneer je klaar bent om het dicht te doen, is het makkelijk om de zijwanden en de bovenplaat toe te voegen en alles met schroeven te bevestigen.

Monteer de Arduino op de basisplaat, voeg voertjes en andere hardware toe om de behuizing in Platform Configuratie voor te bereiden. Zie de stappen in de dia's hieronder – de bijschrift bij elke afbeelding is genummerd en geeft aanvullende uitleg per stap.

Hier zijn alle stappen als een geanimeerde GIF:

Stap 2 - Bereid de MPR121 Shield voor de Arduino voor

Ik knipte 12 stukken 22 AWG lijmdraad op maat. Ik soldeerde deze in de MPR121 Shield. De Adafruit Shield heeft twee grote gaten voor elk van de 12 ingangen voor krokodillenklammen. Tussen deze twee gaten zit een kleiner gat dat een 22 AWG draad past.

De MPR121 Shield blootst ook alle pinnen uit via gaten naast de headers. Ik soldeerde ook een Piezo Buzzer PS1240, met een poot in pin 12 en de andere in GND.

Ik zorgde ervoor dat ik het andere (vrije) uiteinde van elke draad ontmantelde. Ik gebruikte een herhalend patroon van 6 verschillende kleuren voor de 12 ingangen, om ze kleur te coderen, zodat de volgorde later bij de montage bewaard kon blijven.

Stap 3 - Bereid de behuizing voor

Vervolgens bereiden we de behuizing voor. We beginnen met het invoegen van de shield in de Arduino die op de basisplaat gemonteerd is. We voegen dan de bovenste versterkingselementen en de zijwanden in de wandgaten in.

Ik heb de standaard bovenkant van de ProtoStax voor Arduino-behuizing genomen en 12 gaten erin geboord om de draden van de shield-ingangen door te voeren. Ik gebruikte een lasersnijder om de gaten te snijden volgens de pianotoets-sjabloon, maar je kunt ook gewoon een boormachine gebruiken (zet dan wel maskerband op de acrylplaat voordat je boort). Een klein gat van 1/8" zou voldoende moeten zijn.

Vervolgens voeg ik de draden van de shield voorzichtig in de gaten op de bovenplaat in – ik zorg ervoor dat de draad van gat 0 in het linkerste gat gaat, en voeg progressief genummerde draden (ze zijn genummerd op de shield) in de gaten van links naar rechts in. Ik voeg dan de bovenste afstandshouders onder de bovenplaat toe en draai de schroeven vast om de behuizing te voltooien.

Daarna duw ik de draden terug tot alleen de metalen delen buitensteken.

Knip vervolgens stukjes van een rol Koperfolie met Geleidende Lijm in de vorm van de Pianotoetsen uit de sjabloon (zie onder voor sjabloon). Plak ze dan voorzichtig op hun respectieve posities op de bovenplaat van de behuizing, zorg ervoor dat de koperband over de bijbehorende draad die uit het gat steekt, plakt.

Hier is de sjabloon voor de Pianotoetsen en de gaten. Je zou dit op A4-papier moeten kunnen printen en de juiste maat hebben (laat me weten als je problemen hebt!)

Uiteindelijk ziet het er zo uit: (Ik had het beter met de koperfolieband kunnen doen, maar dit was mijn eerste keer, dus hopelijk word ik er beter in! 😊)

Stap 4 - Democode

Je moet eerst de Adafruit_MPR121-bibliotheek installeren. Daarna kun je de voorbeeldsketch compileren en uploaden, die jouw creatie omzet in een touch-piano, inclusief geheime toetsencombinaties om enkele jingels af te spelen.

• Druk C E G B voor "Twinkle Twinkle Little Stars"
• Druk C D E F G voor toonladder omhoog en omlaag
• Druk C D A B voor "Oh Susanna!"
• Druk C Cis Bes B voor "Frere Jacques/Brother John"

Ik heb het ook makkelijk gemaakt om je eigen tunes te transcriberen van bladmuziek.

Als je geïnteresseerd bent in de code (en dat weet ik zeker!), lees dan verder!

Code-structuur

De code bestaat uit 3 delen:

1. Aanraakdata ophalen van MPR121 met de Adafruit_MPR121-bibliotheek.
2. Bepalen wat te doen met de aanraakdata – de bijbehorende toon spelen als een piano, of multi-touch detecteren en de geheime jingle afspelen, allebei met de ingebouwde tone-bibliotheek.
3. Tunes programmeren, inclusief hoe je je eigen tunes toevoegt.

Capacitieve touch-deel van de code

Adafruit_MPR121 cap = Adafruit_MPR121();

void setup() {
  // Standaard adres is 0x5A, als verbonden met 3.3V dan 0x5B
  // Als verbonden met SDA dan 0x5C en als SCL dan 0x5D
  if (!cap.begin(0x5A)) {
    Serial.println("MPR121 not found, check wiring?");
    while (1);
  }
}

void loop() {
  // Huidig aangeraakte pads ophalen
  currtouched = cap.touched();
}

Met de aanraakdata kun je reageren op een aanraking door de bijbehorende toon te spelen, en de toon te stoppen wanneer de toets niet meer wordt ingedrukt:

// Als het *wel* aangeraakt is en *niet* eerder, speel de bijbehorende toon!
if ((currtouched & _BV(i)) && !(lasttouched & _BV(i))) {
  tone(TONE_PIN, scale[i]);
}

// Als het *was* aangeraakt en nu *niet* meer, en geen enkele toets wordt ingedrukt, stop de toon
// Dit zorgt voor soepere overgangen tussen noten als je je vinger over de toetsen schuift
// Dit maakt ook sustain mogelijk van een gegeven noot, door een toets aan te raken en vast te houden
if (!(currtouched & _BV(i)) && (lasttouched & _BV(i)) && !currtouched) {
  noTone(TONE_PIN);
}

We behandelen multi-touch van speciale toetsen door de bijbehorende tune af te spelen:

// Speel tunes als onze 'geheime' combinatie toetsen ingedrukt wordt!
if (currtouched == 2193) { // C E G B
  playTune(melody, MELODY_LENGTH(melody), 2); // Twinkle Twinkle Little Star
} else if (currtouched == 181) { // C D E F G
  playTune(melody2, MELODY_LENGTH(melody2), 48); // Toonladder
} else if (currtouched == 2565) { // C D A B
  playTune(melody3, MELODY_LENGTH(melody3), 1); // Oh Susanna!
} else if (currtouched == 3075) { // C Cis Bes B
  playTune(melody4, MELODY_LENGTH(melody4), 1); // Frere Jacques
}

playTune() speelt een gegeven tune, wat een array van "Note"s is:

void playTune(Note *m, int mSize, int speedUp) {
  noTone(TONE_PIN);
  for (int thisNote = 0; thisNote < mSize; thisNote++) {
    int noteDuration = 1000.0 * m[thisNote].duration / speedUp;
    tone(TONE_PIN, m[thisNote].frequency, noteDuration);
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
    noTone(TONE_PIN);
  }
  delay(100);
}

Een melodie bestaat uit een array van Noten. Elke Noot heeft een frequentie en duur:

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

// Deze melodie speelt alle noten van de octaaf van C tot B en terug naar C
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}
};

De #defines in pitches.h en noteDurations.h zijn handig. Je kunt NOTE_C gebruiken voor een C-toon, en NOTE_WHOLE voor een hele noot (andere: NOTE_HALF, NOTE_QUARTER, NOTE_EIGHTH). Je kunt ook de DOTTED() macro gebruiken voor een "puntnoot" – bijvoorbeeld DOTTED(NOTE_QUARTER).

[Let op: Een puntnoot is een noot wiens duur verlengd is met een noot van half z'n duur – bijvoorbeeld is een puntige halve noot equivalent aan 3/4 van een hele noot (1/2 noot plus 1/2 van 1/2 noot).]

Hiermee kun je elke bladmuziek transcriberen naar je melodie-array!

In de demo heb ik "Twinkle Twinkle Little Star", "Frere Jacques/Brother John" en "Oh Susanna!" getranscribeerd – al deze nummers passen binnen één octaaf. Natuurlijk, bij het afspelen van een geheime tune, ben je niet gebonden aan deze limiet en kun je meerdere octaven gebruiken. "Oh Susanna!" is wat complexer, met halve, kwart en achtste noten en ook "puntige" kwart en halve noten – hopelijk helpt dit je om een goed gevoel te krijgen voor het transcriberen van andere nummers.

Stap 5 - Nog verder gaan!

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

1. Creëer je eigen jingels/tunes (of transcribeer bestaande) en wijs je eigen "Geheime Toetsen" toe om ze te activeren!
2. Voeg een tweede piezo toe voor 2-niveaus polyphone geluiden! De tone-bibliotheek gebruikt Timer2. De Arduino Uno heeft 3 timers, waar Timer 0 speciaal is (millis(), PWM). Dat laat Timer1 over. De NewTone-bibliotheek is een geoptimaliseerde herschrijving van tone die Timer1 gebruikt. Je kunt dus twee tonen tegelijkertijd hebben, een met tone en de andere met NewTone.
3. Voeg een extra knop of twee toe voor extra functionaliteit – zoals het uitbreiden van de octaaf naar een hogere of lagere. Door deze knoppen in combinatie met je capacitieve toetsen in te drukken, kun je een groter bereik op je toetsenbord hebben!

Kun je nog meer bedenken? Laat een reactie achter! 😊 Voel je vrij om vragen te stellen! 😊

Veel plezier met maken! 😊

Code

ProtoStax_CapacitiveTouch_Piano_Demo

Demo voor ProtoStax Piano met ProtoStax voor Arduino Behuizing, Adafruit 12x Capacitive Touch Shield - MPR121, Piezo Buzzer, en Arduino

GitHub Repository

Custom parts en behuizingen

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

Schema's