Guitar Hero Arduino projekt: 12 lépés (képekkel)

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:43

Wij zijn Maarten Vrebos, Justin Cavanas és Wannes Stroobandt, valamint multimédia és kommunikációs technológia. 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 volt ágyazás om de bestaande knoppen op de gitaar intern te vervangen. Onze controller 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 nyomógomb
• 7 1 khm -os ellenállás
• 1 gél LED 1
• blauwe LED
• 1 Arduino Uno R3
• 1 groene LED
• 2 LED világított
• 1 schuifschakelaar
• 1 kenyértábla
• 1 potenciométer
• 1 protobord
• 1 Guitar Hero gitár
• Voldoende ágynemű
• Materiaal om te solderen/dremelen/
• Schroevendraaier

1. lépés: Componenten Verzamelen

Voor ons prototype (op breadboard) hebben we volgende komponens gebruikt:

6 Nyomógombok

7 1 khm -os ellenállás

1 Sárga LED

1 Kék LED

1 Arduino Uno R3

1 Zöld LED

2 Piros LED

1 Schuifschakelaar

1 Kenyeretábla

1 potenciométer

2. lépés: Prototípus Bouwen

Om ons prototype te bouwen hebben we al onze komponens gebruikt op een breadboard, deze breadboard dient dan als testobject zodat we niet meteen in de behuizing te werk moeten gaan. Dit prototype hebben we dan ook gedigitaliseerd via tinkercad.com, op deze manier hadden we een duidelijk overzicht van ons prototype dat elk groepslid ook kon bewerken.

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. A változatos LED-lámpák napfényben vannak, és minden vezérléssel rendelkeznek.

3. lépés: Kód prototípus

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 számok waar mainButton (snaar) en andere gombok aan verbonden zijn: const int mainButton = A1; // gitaar snaar const int lightSensor = A0; const int gombPin1 = 2; // számológép nyomógomb1 const int gombPin2 = 3; // számológép nyomógomb2const int gombPin3 = 4; // számológép nyomógomb3const int gombPin4 = 5; // számológép nyomógomb4const int gombPin5 = 6; // számológép nyomógomb5

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; // a LED -tű száma 13

const int ledPin2 = 12; // a LED -es érintkezők száma 12 const int ledPin3 = 11; // a LED -es érintkezők száma 11 const int ledPin4 = 10; // a LED -es érintkezők száma 10 const int ledPin5 = 9; // a LED -es érintkezők száma 9 const int potPin = A5; // A5 LED -es tű száma

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

// inicializáló buttonStates voor de knoppen (ingedrukt of niet) int mainButtonState = 0; int gombÁllapot1 = 0; int gombÁllapot2 = 0; int gombÁllapot3 = 0; int gombállapot4 = 0; int gombállapot5 = 0; int lightSensorState = 0; int potValue = 0; int lightValue = 0;

Beállít

Ez a vogt setup functie. Deze is van het type void (geeft geen waarde terug) en de instructies hierin worden maar 1 keer uitgevoerd.

A Bij elke functie a kommentárban található, és egy konkrét getaan szó. Extra uitleg over wat een specificieke functie concreet doet is te vinden in de arduino reference

void setup () {// adatsebesség másodpercenként (baud) voor seriele data transmissie Serial.begin (9600); // A LEDPin inicializálása a kimeneti pinMode (ledPin1, OUTPUT); pinMode (ledPin2, OUTPUT); pinMode (ledPin3, OUTPUT); pinMode (ledPin4, OUTPUT); pinMode (ledPin5, OUTPUT); // inicializáló összes nyomógomb 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); }

Üres funkció

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 een array

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

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

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

// deklarátor és tömb mainStates en geef die de standaard waarden 0 in.

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

// hurok a tömb felett aantalKnoppen

for (int i = 0; i <aantalKnoppen; i ++) {pinMode (knopPinnen , INPUT); // inicializáló 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. lépés: Prototípus Uittesten

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

A tweede videóban te zien hoe onze tremolo werkt aan de hand van een potentiometer in de gitaar en hoe de waardes worden uitgelezen in Processing.

5. lépés: Behuizing "ontmantelen" 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 originalinele komponens we eventueel nog zouden kunnen hergebruiken voor onze controller. Használja ezt a gombot, és nyomjuk meg a gombokat a jobb oldalon (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 button gebruikt (zie vierde foto). De LEDjes zullen verdwijnen (deze waren enkel ter indicatie zodat we zagen dat alle knoppen correct werkten).

6. lépés: Werking Originele Buttons + Dremelen

Az egyik leghíresebb videó a 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 gombok te verwerken in de originele knoppen hebben we de binnenkant van de originelen er grotendeels uitgehaald zoals te zien is op de photo.

7. lépés: Bedrading Solderen + Buttons Vastlijmen

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

8. lépés: Plaats Maken De Behuizing -ban

Omdat dit Guitar Hero-modell redelijk krap was om mee te werken hebben we extra plaats moeten maken d.m.v. undorító. 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 buttons 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. lépés: Bedrading Aansluiten Op Protobord

Om alle komponens met elkaar te verbinden hebben we gebruik gemaakt van een protobord. Dit is een bordje dat eigenlijk op net dezelfde manier werkt als een breadbord, maar dan betrouwbaarder en effectiënter. We hebben de bedrading aan het bordje gesoldeerd zoals te zien is op de derde photo. Dit bord is het centrale punt van waaruit al onze verbindingen vertrekken en samenkomen (zie foto 2).

10. lépés: Verstevigen

A befejező érintés az utolsó változat is. 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. lépés: Code Voor Het Communiceren Met Reaper

A Deze kód be van állítva a twee delen -ben, de eerste deel in de arduino IDE (interaktív fejlesztési környezet) geschreven. Ez a kód szó geüpload naar arduino zelf en dient om all waarden van de sensors van de midi controller uit te lezen en door te sturen naar processing.

A feldolgozás het tweede gedeelte. Deze code dient om alles wat arduino doortuurt te ontvangen en door te sturen naar Reaper.

Arduino

/* Ez a kód egy alapvető vázlat a processzorral való kommunikációhoz.

Ez egy tervrajz, amelybe beírhatja saját kódját

saját gombjaihoz, potenciométereihez vagy érzékelőihez.

Kézfogással rendelkezik, hogy megbizonyosodjon róla, hogy kapcsolatba lépünk

és a formátum, amelyben kommunikálunk, eldől

Fontos, hogy az üzenetet így építsük fel, hogy a Processing tudja, hogyan kell dekonstruálni és helyes OSC-üzeneteket küldeni a DAW-nak

a werkcollege AV&IT számára készült

2017 okt

*

/ átviteli sebesség

const hosszú baudRate = 115200;

// idő várni ms -ban a lekérdezések és a gombostűk között

const int loopPauseTime = 200; // milli másodperc

// a Serialon küldött üzenet kezdő és befejező értékei

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

const char contactCharacter = '|';

// pin azonosítók

// egyéb globális változók

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;

// analóg érzékelők

const int potPin = A5; // pin voor tremolo

// Erre a funkcióra szükségünk van ahhoz, hogy kapcsolatba lépjünk a Processing vázlattal

// Tartsa itt void createContact () {while (Serial.available () <= 0) {Serial.print (contactCharacter); // karakter küldése és válasz várása… delay (loopPauseTime); } Serial.read (); }

void setup () {

// állítsa be a pinModes módot az összes csaphoz (int i = 0; i <aantalKnoppen; i ++) {pinMode (knopPinnen , INPUT); } pinMode (mainButton, INPUT); // megjegyzés, ha 5 V helyett 3 V -os szenzorokat használ // akkor az „ext” tűt 3,3 V -ra kell kötni // analogReference (EXTERNAL);

// inicializálja a Soros vesszőket

Serial.begin (baudRate); while (! Sorozat); // várja meg a kézfogást createContact (); }

void loop () {

// 1. LÉPÉS: GOMBOK OLVASÁSA // lekérdezi az összes gombostűt, és leképezi a leolvasást a megfelelő tartományba 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); // példák: // float v0 = map (bpm, 0, 1023, 60, 250); // ha normalizált lebegést szeretne használni (pl. kötethez) // float v1 = map (analogRead (pin2), fromMin, fromMax, 0, 100) / 100.0;

// 2. LÉPÉS: ÜZENET ÍRÁSA

Serial.print (startString); // üzenetsorozat indítása (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 (térkép (potValue, 0, 1023, 0, 100)); // írja az üzenet végét Serial.print (endString);

// várjon egy kicsit..

delay (loopPauseTime); }

Feldolgozás

Jogi nyilatkozat: Niet all code van de processing sketch staat hier in geschreven, voor de volledige code 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

végső int baudRate = 115200;

// Zoek naar het IP -cím aratógépben (zie screenshotok a bizsukban)

Stuurt naar dit andres en reaper luistert hier naar feldolgozása

// végső karakterlánc távoliIP = "192.168.1.43"; //például. "127.0.0.1";

final String remoteIP = "10.3.209.60";

// Jegyezze fel a sendPort -ot, és töltse ki a Reaper -ben.

// Ez az a port, amelyet a Processing küld és a Reaper hallgat.

végső int listenPort = 12000, sendPort = 12000;

// A listenPort itt aktív hibakeresés.

// a portNames szintén hibakeresésre szolgál.

// végső karakterlánc portName = "/dev/ttyACM0";

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

////////////////////// FELHASZNÁLÓI PARAMÉTEREK VÉGE //////////////////////// ////

import feldolgozás.sorozat.*;

import java.util.*;

import oscP5.*;

import netP5.*;

OscP5 oscP5;

NetAddress myRemoteLocation;

Soros commsPort; // A soros port

logikai üzenetArrived = false;

String bejövő = "", IncomingOSCMessage = "";

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

// Annak érdekében, hogy csak a változó paramétereket (értékeket) küldjük

// ezek a globális variablok itt vannak, de // nem szabad itt inicializálni! HashMap oldParams, newParams, toSendParams;

// Minden vesszőnél fel kell osztanunk az üzenetet

void processIncoming () {String resVec = bejövő.osztás (","); // név+értékpárokat kapunk // így minden névhez (+2)… próbálkozzon {for (int i = 0; i <resVec.length; i+= 2) {float value = Float.parseFloat (resVec [i+ 1]); // tegye őket az új Hashtable newParams.put (resVec , érték); }} // ha hiba történik, akkor jelenítsük meg és lépjünk ki. catch (Exception ex) {println ("Kivételüzenet:" + ex); printArray (resVec); kijárat(); }}

// Üzeneteink szűrése

/ * Győződünk meg arról, hogy csak OSC-out üzenet jelenik meg, amikor * a bemeneti üzenet (soros) megváltozik * Vagyis: ha elfordítjuk/megnyomjuk a gombot, és ez megváltoztatja az értéket. * Tehát kiszűrjük a ténylegesen változó bejövő értékeket * Megjegyzés: nem fogjuk elkerülni az ugró értékeket *, mint pl. Gyorsulásmérők vagy távolságérzékelők * * ezeket az Arduino programban kell simítani * HashMap (); for (String key: newParams.keySet ()) {// ha a kulcs már megvan, ha (oldParams.containsKey (key)) {// a kulcs jelen van és értéke nem ugyanaz, akkor frissítse, ha (! oldParams.get (key).equals (newParams.get (kulcs))) {toSendParams.put (kulcs, newParams.get (kulcs)); }} else {// kulcs nincs jelen a régi paraméterekben, szóval tedd meg! toSendParams.put (kulcs, newParams.get (kulcs)); } oldParams.put (kulcs, newParams.get (kulcs)); }}

void makeOSC () {

for (String key: toSendParams.keySet ()) {OscMessage myMessage = new OscMessage ("/"+ key); myMessage.add (toSendParams.get (kulcs)); / * küldje el az üzenetet */ oscP5.send (myMessage, myRemoteLocation); }}

void translateMessage () {

processIncoming (); filterParams (); makeOSC (); } // Ha az ablakba szeretnénk nyomtatni void ShowIncoming () {// a bejövő üzenetek megtekintéséhez, a HashMap szövegben meghatározottak szerint ("Bejövő Arduino -tól", 20, 20); int y = 20; for (Karakterlánc kulcs: newParams.keySet ()) {y = y+20; szöveg (kulcs, 20, y); szöveg (newParams.get (kulcs), 300, y); }}

void showOsc () {

szöveg (IncomingOSCMessage, 300, 200); IncomingOSCMessage = ""; }

void setup () {

méret (1000, 800); // Színpadméret kitöltés (255); háttér (0); oldParams = új HashMap (); newParams = új HashMap (); // printArray (Serial.list ()); commsPort = új soros (ez, portName, baudRate);

/ * indítsa el az oscP5 -öt, figyelje a bejövő üzeneteket */

oscP5 = új OscP5 (ez, listenPort);

/* A myRemoteLocation egy NetAddress. a NetAddress 2 paramétert tartalmaz, * IP -cím és portszám. A myRemoteLocation paramétert használja az * oscP5.send () fájlban, amikor osc csomagokat küld egy másik számítógépre, eszközre vagy * alkalmazásba. használatát lásd alább. tesztelés céljából a figyelő port * és a távoli hely címének portja ugyanaz, ezért * vissza fog küldeni üzeneteket erre a vázlatra. */ myRemoteLocation = új NetAddress (remoteIP, sendPort); }

void draw () {

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

void serialEvent (Serial commsPort) {

// bájt olvasása a soros portról: char inChar = commsPort.readChar (); switch (inChar) {case contactCharacter: commsPort.write (contactCharacter); // kérjen további println ("kezdő…"); szünet; case startChar: bejövő = ""; szünet; eset endChar: messageArrived = true; // println ("üzenet vége"); szünet; alapértelmezett: bejövő += inChar; szünet; }}

/* a bejövő osc üzenetet továbbítja az oscEvent metódusba. */

void oscEvent (OscMessage theOscMessage) {float value = theOscMessage.get (0).floatValue (); // szerezze be az 1. osc argumentumot

IncomingOSCMessage += "\ n" +

String.format ("### kapott egy osc üzenetet:" + "addrpattern:" + theOscMessage.addrPattern () + ": %f", érték); println (IncomingOSCMessage); }

12. lépés: Uittesten vezérlő

Nu alles is aangesloten, all code is geschreven en alles is gedubbelcheckt is het eindelijk tijd om de controller z'n werk te latten doen. Zoek és pár leuke effektusok a Reaper -ben és a Guitar Hero MIDI Controller generációjában!