Kitarrikangelase Arduino projekt: 12 sammu (piltidega)

2024 Autor: John Day | [email protected]. Viimati modifitseeritud: 2024-01-30 08:50

Wij zijn Maarten Vrebos, Justin Cavanas ja Wannes Stroobandt ning me õpime multimeediat ja kommunikatsioonitehnoloogiat. Voor een groepsproject voor het vak Audiovisual & IT Principles hebben wij een Guitar Hero-gitaar gehackt en gebruikt als behuizing voor onze MIDI-controller. Het oli voodipesu om de bestaande knoppen op de gitaar intern te vervangen. Onze kontroller zal vastgehouden en bespeeld worden als een normale gitaar. Aangezien we iets hebben gehackt hebben we er niet veel extra material in moeten verwerken.

In de afbeelding kan u onze allereerste schets op papier zien van hoe het eindproduct er zou moeten uitzien met daarnaast een photo van de gitaar die als behuizing zal worden gebruikt.

Wij hebben ons voor dit project gebaseerd op volgende bronnen:

slapyak.wordpress.com/guitar-hero-midi-con…

www.instructables.com/id/Converting-a-rescu…

gizmodo.com/391834/turn-your-guitar-hero-g…

Benodigdheden voor dit projekt

• 6 kleine -nuppu
• 7 1kohm takisti
• 1 raud LED 1
• blauwe LED
• 1 Arduino Uno R3
• 1 Groene LED
• 2 LED -i
• 1 schuifschakelaar
• 1 leivalaud
• 1 potentsiomeeter
• 1 protobord
• 1 kitarrikitarri kitarr
• Voldoende voodipesu
• Materiaalne om te solderen/dremelen/
• Schroevendraaier

Samm 1: Componenten Verzamelen

Voor ons prototüüp (op leivaplaat) hebben we volgende komponendid gebruikt:

6 nuppe

7 1kohm takisti

1 kollane LED

1 sinine LED

1 Arduino Uno R3

1 roheline LED

2 Punane LED

1 Schuifschakelaar

1 Leivalaud

1 potentsiomeeter

2. samm: prototüüp Bouwen

Om ons prototype te bouwen hebben we al onze komponenten gebruikt op een breadboard, deze breadboard dient dan als testobject zodat we niet meteen in de behuizing te werk moeten gaan. Kui prototüüp on saadaval, siis saame selle teenuse tinkercad.com kaudu kuvada, see on saadaval, kuid me ei saa seda enam teha, kui see on prototüüp.

Er worden 5 kleine pushbuttons gebruikt die fungeren als 5 snaren en een grote pushbutton die in combinatie met één of meerdere 'snaren' moet worden ingedrukt om een auditief effect te krijgen. Valgusdioodide LED-lampide päevad on samuti reguleeritavad, kuna need on interaktiivsed ja edukad.

Samm: koodi prototüüp

Globale variabelen

In het eerste deel van de code initialiseer je globale variabelen voor de pins van arduino uno waar alle pushbuttons mee verbonden zijn.

// zet pin numbrid waar mainButton (snaar) et andere nupud aan verbonden zijn: const int mainButton = A1; // gitaar snaar const int lightSensor = A0; const int nuppPin1 = 2; // nummer van pushbutton1 const int nuppPin2 = 3; // nummer van pushbutton2const int nuppPin3 = 4; // nummer van pushbutton3const int nuppPin4 = 5; // nummer van pushbutton4const int nuppPin5 = 6; // nummer van nupp5

Hierna worden er twee arrays aangemaakt voor de namen van de pushbuttons en hun pinnummer.

const int aantalKnoppen = 5; const String namenKnoppen [aantalKnoppen] = {"knop 1", "knop 2", "knop 3", "knop 4", "knop 5"}; const int knopPinnen [aantalKnoppen] = {2, 3, 4, 5, 6};

En dan nog variabelen voor de pins van de LED lichtjes.

const int ledPin1 = 13; // LED -tihvti number 13

const int ledPin2 = 12; // LED -pinide arv 12 const int ledPin3 = 11; // LED -pinide arv 11 const int ledPin4 = 10; // LED -i tihvtide arv 10 const int ledPin5 = 9; // LED -i tihvtide arv 9 const int potPin = A5; // LED -pin A5 arv

De laatste globale variabelen dienen als 'States' voor de sensors (zijn de pushbuttons ingedrukt of niet? Potentiometer, lichtsensor).

// Initialize buttonStates voor de knoppen (ingedrukt of niet) int mainButtonState = 0; int nuppOlek1 = 0; int nuppOlek2 = 0; int nuppOlek3 = 0; int nuppRiik4 = 0; int nuppOlek5 = 0; int lightSensorState = 0; int potValue = 0; int lightValue = 0;

Seadistamine

See on tühine seadistusfunktsioon. Deze is van het type void (geeft geen waarde terug) en de instructies hierin worden maar 1 keer uitgevoerd.

Bij elke functie on kommentaar geschreven või konkreetne getaan. Extra uitleg over wat een specificieke functie concreet doet is te vinden in de arduino reference

void setup () {// andmeedastuskiirus sekundis (baud) voor seeria andmeedastus Serial.begin (9600); // LEDPin algseadistuse väljund pinMode (ledPin1, OUTPUT); pinMode (ledPin2, OUTPUT); pinMode (ledPin3, OUTPUT); pinMode (ledPin4, OUTPUT); pinMode (ledPin5, OUTPUT); // initsialiseerides kõik nupud als input: pinMode (mainButton, INPUT); pinMode (buttonPin1, INPUT); pinMode (buttonPin2, INPUT); pinMode (buttonPin3, INPUT); pinMode (buttonPin4, INPUT); pinMode (buttonPin5, INPUT); pinMode (potPin, INPUT); pinMode (lightSensor, INPUT); }

Tühi funktsioon

Na de setup () functie volgt de loop () functie, de instructies die hierin staan gaan herhaald uitgevoerd worden.

void loop () {// lees de staat van de pushbuttons uit (ingedrukt of niet) mainButtonState = digitalRead (mainButton); buttonState1 = digitalRead (buttonPin1); buttonState2 = digitalRead (buttonPin2); buttonState3 = digitalRead (buttonPin3); buttonState4 = digitalRead (buttonPin4); buttonState5 = digitalRead (buttonPin5);

// alle pushbutton statusen in massiiv

int buttonStates = {buttonState1, buttonState2, buttonState3, buttonState4, buttonState5};

// leest de waarde uit van de potentiometer en de lichtsensor

potValue = analogRead (potPin); lightValue = analogRead (lightSensor);

// deklareerija ja massiiv mainStates en geef die de standaard waarden 0 in.

int mainStates = {0, 0, 0, 0, 0};

// loop üle massiivi aantalKnoppen

for (int i = 0; i <aantalKnoppen; i ++) {pinMode (knopPinnen , INPUT); // Initialiseer alle knopPinnen als input digitalRead (knopPinnen ); // lees de waarde van alle knoppinnen uit // indien de mainswitch (snaar) ingedrukt is, print alle knopnamen, alle buttonstates if (mainButtonState == HIGH) {Serial.print (namenKnoppen ); Serial.print (","); Serial.println (buttonStates ); }}

4. samm: prototüüp Uittesten

Nadat het prototype gebouwd is volgens ons model and de code geschreven is in Processing, is het tijd om het prototype uit te testen. Op de video is te zien dat alle knoppen een reageering geven op de bijhorende ledjes en data ook combinaties van knoppen mogelijk zijn.

In tweede video on te zien hoe onze tremolo werkt aan de hand van een potentiometer in de gitaar en hoe de waardes worden uitgelezen in Processing.

Samm 5: "Ontmantelen" Behuizing En Kijken Welke Componenten Gebruikt Gaan Worden

Als de code correct werkte op het prototype zijn we begonnen met het "ontmantelen" van onze Guitar Hero-gitaar. We hebben de gitaar opengemaakt met een schroevendraaier en bekeken welke originele komponenten we eventueel nog zouden kunnen hergebruiken voor onze controller. Uiteindelijk hebben we onze ei pushbuttons in de bestaande nupud gekregen (zie volgende stap). We hebben de tremolo ook gebruikt voor ons eindproduct en voor onze hoofdbutton (initiële button om als een combinatie af te spelen) hebben we ook de originele twee nupud gebruikt (zie vierde foto). De LEDjes zullen verdwijnen (deze waren enkel ter indicatie zodat we zagen dat alle knoppen correct werkten).

6. samm: originaali nuppude tõmbamine + Dremelen

Ehitusteemaline video on de wijze te zien waarop de twee originele knoppen werken als een soort van schakelaar die wij gebruiken om een effect te genereren bij combinatie van knoppen.

Om onze eigen nupud te verwerken in de originele knoppen hebben we de binnenkant van de originelen er grotendeels uitgehaald zoals te zien is op de foto.

7. samm: Bedrading Solderen + nupud Vastlijmen

Omdat we niet meer met een breadboard werken moeten de draden gesoldeerd worden om zo de verschillende komponendid met elkaar te verbinden. Nadat dit gebeurd is kunnen we de nuppude vastlijmen zoals te zien is op de foto's. Eens dit gebeurd is kunnen we doorgaan naar de volgende stap.

8. etapp: Plaats Maken De Behuizingis

Omdat dit Guitar Hero-modell redelijk krap was om mee te werken hebben we extra plaats moeten maken d.m.v. kurnav. Zo hebben we uit de achterkant van de gitaar een hele strook verwijderd zodat er meer plaats ontstaat voor de bedrading in de gitaar. Omdat er overal in de binnenkant obstakels waren, waaronder veel buisjes om de vijzen in te bevestigen, hebben we die ook verwijderd om optimaal van de gegeven ruimte gebruik te kunnen maken. Op de vierde en vijfde foto is te zien dat we in de achterkant van de gitaar een doorgang hebben gecreëerd voor de draden die naar de nupud gaan omdat de gitaar anders niet meer te sluiten was. En op de laatste foto is te zien dat we de draden die rechtstreeks verbonden worden met de Arduino door een gat in de onderkant van de gitaar de behuizing verlaten.

9. samm: Bedrading Aansluiten Op Protobord

Om alle komponendid met elkaar te verbinden hebben we gebruik gemaakt van een protobord. See on bordje ja see ei sisalda teavet võrgu kohta, mis on leibord, maar dan betrouwbaarder ja tõhusus. We hebben de bedrading aan het bordje gesoldeerd zoals te zien is op de derde foto. Dit bord is het centrale punt van waaruit al onze verbindingen vertrekken en samenkomen (zie foto 2).

10. samm: Verstevigen

Viimane puudutus on ka verstandig om de losse delen te verstevigen voor extra stabiliteit. Op deze foto is te zien hoe we het deel dat we er hebben uitgehaald d.m.v. dremelen achteraan de buttons verstevigen met stukjes karton.

11. samm: kood Voor Het Communiceren Met Reaper

Deze kood on sisse lülitatud kaks korda, kuid eerste deel on de arduino IDE (interaktiivne arenduskeskkond) geschreven. Koodsõna geüpload naar arduino zelf en dient om alle waarden van de sensors van de midi controller uit te lezen en door te sturen naar processing.

Töötlemine on het tweede gedeelte. Deze code dient om alles wat arduino doortuurt te ontvangen en door te sturen naar Reaper.

Arduino

/* See kood on põhijoonis, et suhelda töötlemisega jada kaudu.

See on plaan, kuhu saate oma koodi sisestada

määratud teie nuppude, potentsiomeetrite või andurite jaoks.

Sellel on käepigistus, et tagada kontakt

ja otsustatakse, millises vormis me suhtleme

Oluline on sõnum üles ehitada samamoodi, nii et töötlemine teab, kuidas seda dekonstrueerida ja saata meie DAW-le õiged OSC-sõnumid

tehtud töökolleegiumi AV&IT jaoks

oktoober 2017

*

/ baud kiirus

const pikk baudRate = 115200;

// aeg oodata ms -is tihvtide küsitluste vahel

const int loopPauseTime = 200; // milli sekundit

// Serialis saadetud sõnumi algus- ja lõppväärtused

const String startString = "*", endString = "#";

const char contactCharacter = '|';

// PIN -id

// muud globaalsed muutujad

const int aantalKnoppen = 5; const String namenKnoppen [aantalKnoppen] = {"knop 1", "knop 2", "knop 3", "knop 4", "knop 5"}; const int knopPinnen [aantalKnoppen] = {2, 3, 4, 5, 6}; const int mainButton = A1;

int mainButtonState = 0;

int potValue = 0;

// analoogandurid

const int potPin = A5; // pin voor tremolo

// Me vajame seda funktsiooni töötlemise visandiga kontakti loomiseks

// Hoidke see siin void createContact () {while (Serial.available () <= 0) {Serial.print (contactCharacter); // saata sümbol ja oodata vastust… delay (loopPauseTime); } Serial.read (); }

tühine seadistus () {

// määrake pinModes kõigi tihvtide jaoks (int i = 0; i <aantalKnoppen; i ++) {pinMode (knopPinnen , INPUT); } pinMode (mainButton, INPUT); // kommenteerige, kui kasutate andureid, mis töötavad 3 V asemel 5 V // peate ühendama ka välimise tihvti 3,3 V külge // analogReference (EXTERNAL);

// initsialiseeri jadamiskommid

Serial.begin (baudRate); while (! Seeria); // oodake käepigistuse loomistContact (); }

void loop () {

// 1. SAMM: LUGEGE NUPPE // küsitlege kõik nööpnõelad ja kaardistage näit sobivasse vahemikku int buttonStates [aantalKnoppen]; /* buttonStates [0] = digitalRead (knopPinnen [0]); buttonStates [1] = digitalRead (knopPinnen [1]); buttonStates [2] = digitalRead (knopPinnen [2]); buttonStates [3] = digitalRead (knopPinnen [3]); buttonStates [4] = digitalRead (knopPinnen [4]); */ mainButtonState = digitalRead (mainButton); for (int i = 0; i <aantalKnoppen; i ++) {buttonStates = digitalRead (knopPinnen ); } potValue = analogRead (potPin); // näited: // float v0 = kaart (bpm, 0, 1023, 60, 250); // kui soovite kasutada normaliseeritud ujukit (nt helitugevuse jaoks) // float v1 = map (analogRead (pin2), fromMin, fromMax, 0, 100) / 100.0;

// 2. SAMM: KIRJUTA SÕNUM

Serial.print (startString); // käivitage sõnumite järjestus (int i = 0; i <aantalKnoppen; i ++) {if (mainButtonState == HIGH) {Serial.print (namenKnoppen ); Serial.print (","); Serial.print (buttonStates ); if (i <aantalKnoppen - 1) {Serial.print (","); }} else {buttonStates = 0; Serial.print (namenKnoppen ); Serial.print (","); Serial.print (buttonStates ); if (i <aantalKnoppen - 1) {Serial.print (","); }}} Serial.print (","); Serial.print ("tremolo"); Serial.print (","); Serial.print (kaart (potValue, 0, 1023, 0, 100)); // kirjutage kirja lõpp Serial.print (endString);

// oota natuke..

delay (loopPauseTime); }

Töötlemine

Vastutusest loobumine: visandi töötlemisviisi staatuse muutmine geschrevenis, voor de volledige kood zie het bestand: ProcessingSoundControl_handout_v6_1.pde in bijlage

De volgende instructies moeten aangepast worden (indien nodig):

// Baudrate moet hetzelfde zijn zoals in de arduino sketch

lõplik int baudRate = 115200;

// Zoek naar het IP aadress reaper (zie screenshots in bijlage)

// Stuurti töötlemine naar dit andres en reaper luistert hier naar //

// lõplik String remoteIP = "192.168.1.43"; // nt. "127.0.0.1";

final String remoteIP = "10.3.209.60";

// Võtke teadmiseks sendPort ja täitke see Reaperis.

// See on port, mida töötlemine saadab ja mida Reaper kuulab.

lõplik int listenPort = 12000, sendPort = 12000;

// Kuulamisport siin on aktiivne silumine.

// ka portNames on siin silumiseks.

// lõplik stringi portName = "/dev/ttyACM0";

final String portName = "COM5"; // "/dev/ttyUSB0";

///////////////////// KASUTAJA PARAMETRITE LÕPP //////////////////////// ////

impordi töötlemine.seriaalne.*;

import java.util.*;

import oscP5.*;

import netP5.*;

OscP5 oscP5;

NetAddress myRemoteLocation;

Serial commsPort; // jadaport

boolean messageArrived = false;

String sissetulev = "", IncomingOSCMessage = "";

final char startChar = '*', endChar = '#'; final char contactCharacter = '|';

// Veendumaks, et saadame ainult muutuvaid parameetreid (väärtusi)

// need globaalsed variablid on siin delcared, kuid neid ei tohiks siin initsialiseerida! HashMap oldParams, newParams, toSendParams;

// Me peame sõnumi jagama iga komaga

void processIncoming () {String resVec = sissetulev.lõhe (","); // saame nime+väärtuspaarid // nii iga nime (+2) jaoks… proovige {jaoks (int i = 0; i <resVec.length; i+= 2) {float value = Float.parseFloat (resVec [i+ 1]); // pane need uude Hashtable newParams.put (resVec , väärtus); }} // kui ilmneb tõrge, vaatame selle kuvamise välja ja väljume. catch (Erand erand) {println ("Eranditeade:" + ex); printArray (resVec); väljumine (); }}

// Meie sõnumite filtreerimiseks

/ * Veendume, et * sisendteate (jada) muutumisel on ainult OSC-väljumise teade * See tähendab: kui keerame/vajutame nuppu ja see muudab väärtust. * Seega filtreerime välja sissetulevad väärtused, mis tegelikult muutuvad. * Märkus: me ei väldi hüppavaid väärtusi *, mis pärinevad nt kiirendusmõõturitelt või kaugusanduritelt *, peate need ise Arduino -s siluma HashMap (); for (Stringi võti: newParams.keySet ()) {// kui võti on juba olemas, kui (oldParams.containsKey (võti)) {// võti on olemas ja väärtus pole sama, siis värskendage, kui (! oldParams.get (võti).equals (newParams.get (võti))) {toSendParams.put (võti, newParams.get (võti)); }} else {// võtit pole vanades parameetrites, nii et pange see! toSendParams.put (võti, newParams.get (võti)); } oldParams.put (võti, newParams.get (võti)); }}

tühine makeOSC () {

for (Stringi võti: toSendParams.keySet ()) {OscMessage myMessage = new OscMessage ("/"+ võti); myMessage.add (toSendParams.get (võti)); / * saatke sõnum */ oscP5.send (myMessage, myRemoteLocation); }}

void translateMessage () {

processIncoming (); filterParams (); makeOSC (); } // Kui tahame printida aknasse void ShowIncoming () {// sissetuleva sõnumi nägemiseks, nagu on määratud HashMapi tekstis ("Saabuv Arduino", 20, 20); int y = 20; for (Stringi võti: newParams.keySet ()) {y = y+20; tekst (võti, 20, y); tekst (newParams.get (võti), 300, y); }}

void showOsc () {

tekst (IncomingOSCMessage, 300, 200); IncomingOSCMessage = ""; }

tühine seadistus () {

suurus (1000, 800); // Lava suuruse täitmine (255); taust (0); oldParams = uus HashMap (); newParams = uus HashMap (); // printArray (Serial.list ()); commsPort = uus jada (see, pordiNimi, baudRate);

/ * käivitage oscP5, kuulake sissetulevaid sõnumeid */

oscP5 = uus OscP5 (see, kuulamisport);

/* myRemoteLocation on NetAddress. NetAddress võtab 2 parameetrit, * IP -aadress ja pordi number.myRemoteLocation kasutatakse parameetrina * oscP5.send () osc -pakettide saatmisel teise arvutisse, seadmesse või * rakendusse. kasutamist vaata allpool. testimise eesmärgil on kuulamisport * ja kauge asukoha aadressi port sama, seega saadate * sõnumid sellele visandile tagasi. */ myRemoteLocation = uus NetAddress (remoteIP, sendPort); }

tühine viik () {

if (messageArrived) {background (0); translateMessage (); ShowIncoming (); messageArrived = false; } showOsc (); }

void serialEvent (Serial commsPort) {

// jadaportist baiti lugeda: char inChar = commsPort.readChar (); switch (inChar) {case contactCharacter: commsPort.write (contactCharacter); // küsi lisa println ("alustades …"); murda; juhtum startChar: sissetulev = ""; murda; case endChar: messageArrived = true; // println ("sõnumi lõpp"); murda; vaikimisi: sissetulev += inChar; murda; }}

/* sissetulev osc -teade edastatakse oscEvent -meetodile. */

void oscEvent (OscMessage theOscMessage) {float value = theOscMessage.get (0).floatValue (); // saada 1. osc argument

IncomingOSCMessage += "\ n" +

String.format ("### sai osc -teate:" + "addrpattern:" + theOscMessage.addrPattern () + ": %f", väärtus); println (IncomingOSCMessage); }

12. samm: kontroller Uittesten

Nu alles on aangesloten, alle code is geschreven en alles is gedubbelcheckt is het eindelijk tijd om de controller z'n werk te latten doen. Zoek ja paar leuke efekti Reaper ja genitar van de voltooide Guitar Hero MIDI Controller!