Projecte Arduino de Guitar Hero: 12 passos (amb imatges)

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:16

Wij zijn Maarten Vrebos, Justin Cavanas en Wannes Stroobandt en we studeren multimedia & communicatietechnologie. 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 was onze bedoeling om de bestaande knoppen op de gitaar intern te vervangen. Onze controller zal vastgehouden en bespeeld worden als een normal gitaar. Aangezien we iets hebben gehackt hebben we er niet veel extra materiaal 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 foto van de gitaar die als behuizing zal worden gebruikt.

Hi hebben ons for 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 project

• 6 polsadors kleine
• 7 resistències de 1 kohm
• 1 LED gele 1
• blauwe LED
• 1 Arduino Uno R3
• 1 LED groene
• 2 LEDs muntats
• 1 schuifschakelaar
• 1 tauleta de suport
• 1 potenciòmetre
• 1 protobord
• 1 Guitar Hero gitaar
• Voldoende llit
• Materiaal om te solderen / dremelen /
• Schroevendraaier

Pas 1: Componenten Verzamelen

Per a un prototip (taula de treball opcional) hebben we volgende componenten gebruikt:

6 polsadors

7 resistències de 1 kohm

1 LED groc

1 LED blau

1 Arduino Uno R3

1 LED verd

2 LED vermell

1 Schuifschakelaar

1 tauler de pa

1 Potenciòmetre

Pas 2: prototip de Bouwen

Om ons prototype te bouwen hebben we on onze componenten 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. De verschillende LED-lampjes dienen gewoon als visuele control om er zeker van te zijn dat of interactie successvol werkt.

Pas 3: prototip de codi

Globale variabelen

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

// zet pin numbers waar mainButton (snaar) en andere buttons aan verbonden zijn: const int mainButton = A1; // gitaar snaar const int lightSensor = A0; const int buttonPin1 = 2; // nummer van pushbutton1 const int buttonPin2 = 3; // nummer van pushbutton2const int buttonPin3 = 4; // nummer van pushbutton3const int buttonPin4 = 5; // nummer van pushbutton4const int buttonPin5 = 6; // nummer van pushbutton5

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; // el número del pin LED 13

const int ledPin2 = 12; // el nombre de pin LED 12 const int ledPin3 = 11; // el nombre de pin LED 11 const int ledPin4 = 10; // el nombre de pin LED 10 const int ledPin5 = 9; // el nombre de pin LED 9 const int potPin = A5; // el nombre de pin LED A5

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

// initialiseer buttonStates voor de knoppen (ingedrukt of niet) int mainButtonState = 0; int buttonState1 = 0; int buttonState2 = 0; int buttonState3 = 0; int buttonState4 = 0; int buttonState5 = 0; int lightSensorState = 0; int potValue = 0; int lightValue = 0;

Configuració

No volgt de void setup function. Deze is van het type void (geeft geen waarde terug) en de instructies hierin worden maar 1 keer uitgevoerd.

Bij elke function is commentaar geschreven wat er concreet gedaan wordt. Extra uitleg over wat een specifieke functie concreet doet is you vinden in de arduino reference

void setup () {// data rate per seconde (baud) voor seriele data transmissie Serial.begin (9600); // Initialiseer de ledPin variable als output pinMode (ledPin1, OUTPUT); pinMode (ledPin2, OUTPUT); pinMode (ledPin3, OUTPUT); pinMode (ledPin4, OUTPUT); pinMode (ledPin5, OUTPUT); // inicialitzador de tots els polsadors com a entrada: pinMode (mainButton, INPUT); pinMode (buttonPin1, INPUT); pinMode (buttonPin2, INPUT); pinMode (buttonPin3, INPUT); pinMode (buttonPin4, INPUT); pinMode (buttonPin5, INPUT); pinMode (potPin, INPUT); pinMode (lightSensor, INPUT); }

Funció buida

Na de setup () functie volgt de loop () function, 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);

// tots els estats del polsador en una matriu

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

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

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

// declareer een array mainStates en geef die de standaard waarden 0 in.

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

// fa un bucle sobre la matriu aantalKnoppen

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

Pas 4: prototip d'utilització

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 de video is te zien dat all knoppen een reactie geven op de bijhorende ledjes en dat ook combinaties van knoppen mogelijk zijn.

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

Pas 5: Behuizing "ontmantelen" En Kijken Welke Componenten Gebruikt Gaan Worden

Als codes 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 components we eventueel nog zouden kunnen hergebruiken voor onze controller. Uiteindelijk hebben we onze eigen pushbuttons in de bestaande buttons gekregen (zie volgende stap). We heben 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 buttons gebruikt (zie vierde foto). De LEDjes zullen verdwijnen (deze waren enkel ter indicatie zodat we zagen dat alle knoppen correct werkten.

Pas 6: Comerçar els botons Originele + Dremelen

Op de bijhorende video is 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 buttons te verwerken in de originele knoppen hebben we de binnenkant van de originelen er grotendeels uitgehaald zoals te zien is op de foto.

Pas 7: Escalfament Solderen + Buttons Vastlijmen

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

Pas 8: Plaats Maken a De Behuizing

Omdat dit Guitar Hero-model redelijk krap was om mee te werken hebben we extra plaats moeten maken d.m.v. dremelen. 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.

Pas 9: Estratègia de protecció del llit

Om all componentsen 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 efficiënter. We heben 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).

Pas 10: Verstevigen

Tot el toc final és versatil per a la pèrdua de la seva experiència i per a una estabilitat addicional. 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.

Pas 11: Codi Voor Het Communiceren Met Reaper

El codi Deze està disponible a twee delen, però aquest document es troba a l'arduino IDE (entorn de desenvolupament interactiu) geschreven. Die code wordt 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.

El processament es realitza en tweede gedeelte. Deze code dient om alles wat arduino doorstuurt te ontvangen en door te sturen naar Reaper.

Arduino

/ * Aquest codi és un esbós bàsic per comunicar-se amb el processament mitjançant sèrie.

És un pla en què podeu posar el vostre propi codi

especificat per als vostres propis botons, potenciòmetres o sensors.

Té una encaixada de mans per assegurar-nos que tenim contacte

i es decideix el format en què ens comuniquem

És important construir el missatge d'aquesta manera, perquè Processament sàpiga desconstruir-lo i enviar missatges OSC correctes al nostre DAW

fet per a werkcollege AV&IT

octubre de 2017

*

/ velocitat de transmissió

const long baudRate = 115200;

// temps per esperar en ms entre les enquestes als pins

const int loopPauseTime = 200; // mil·lis segons

// valors inicials i finals del missatge enviat a Serial

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

const char contactCharacter = '|';

// identificador de pin

// altres variables globals

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 intButó principal = A1;

int MainButtonState = 0;

int potValue = 0;

// sensors analògics

const int potPin = A5; // pin voor tremolo

// Necessitem aquesta funció per establir contacte amb l'esbós de processament

// Mantingueu-lo aquí buit establirContact () {while (Serial.available () <= 0) {Serial.print (contactCharacter); // envieu un caràcter i espereu una resposta … demora (loopPauseTime); } Serial.read (); }

configuració nul·la () {

// configureu els pinModes per a tots els pins per a (int i = 0; i <aantalKnoppen; i ++) {pinMode (knopPinnen , INPUT); } pinMode (mainButton, INPUT); // descomenteu si feu servir sensors que funcionen a 3V en lloc de 5V // també haureu de connectar el pin 'ext' a 3,3V // analogReference (EXTERNAL);

// inicialitzar comunicacions de sèrie

Serial.begin (baudRate); mentre que (! sèrie); // esperar encaixada de mans establirContact (); }

bucle buit () {

// PAS 1: LLEGIR BOTONS // sondejar tots els pins i assignar la lectura al rang adequat 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); // exemples: // float v0 = map (bpm, 0, 1023, 60, 250); // si voleu utilitzar un float normalitzat (per exemple, per volum) // float v1 = map (analogRead (pin2), fromMin, fromMax, 0, 100) / 100.0;

// PAS 2: ESCRIURE MISSATGE

Serial.print (startString); // iniciar una seqüència de missatges per a (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 (mapa (potValue, 0, 1023, 0, 100)); // escriure el final del missatge Serial.print (endString);

// Espera un moment..

delay (loopPauseTime); }

Processament

Exempció de responsabilitat: No es pot descarregar cap codi de processament a l'esbós, ni el codi vigent, sinó el millor: ProcessingSoundControl_handout_v6_1.pde in bijlage

De volgende instrueix moeten aangepast worden (indien nodig):

// Baudrate moet hetzelfde zijn zoals in de arduino sketch

final int baudRate = 115200;

// Cercar l'adreça IP a reaper (captures de pantalla a bijlage)

// Processing stuurt naar dit andres en reaper luistert hier naar //

// final String remoteIP = "192.168.1.43"; //per exemple. "127.0.0.1";

final String remoteIP = "10.3.209.60";

// Pren nota del sendPort i emplena-ho a Reaper.

// Aquest és el port que envia Processing i escolta Reaper.

final int listenPort = 12000, sendPort = 12000;

// El ListenPort aquí és per depurar activament.

// els portNames també són aquí per depurar-los.

// nom_port final de la cadena = "/ dev / ttyACM0";

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

///////////////////// FI DE PARÀMETRES D'USUARI ///////////////////////// ////

processament de la importació. sèrie. *;

importa java.util. *;

importació oscP5. *;

importar netP5. *;

OscP5 oscP5;

NetAddress myRemoteLocation;

Comunicacions en sèrie; // El port sèrie

missatge booleà Arribat = fals;

Cadena entrant = "", IncomingOSCMessage = "";

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

// Per assegurar-nos que només enviem els paràmetres (valors) que canvien

// Aquests variables globals són descarregats aquí, però // no s’han d’inicialitzar aquí. HashMap oldParams, newParams, toSendParams;

// Hem de dividir el missatge a cada coma

void processIncoming () {String resVec = incoming.split (","); // obtenim parells nom + valor // així que per a cada nom (+2) … proveu {for (int i = 0; i <resVec.length; i + = 2) {float value = Float.parseFloat (resVec [i + 1]); // col·loqueu-los al nou Hashtable newParams.put (resVec , valor); }} // si es produeix un error, capturem la visualització i la sortida. catch (Exception ex) {println ("Missatge d'excepció:" + ex); printArray (resVec); sortir (); }}

// Per filtrar els nostres missatges

/ * Ens assegurem que només hi hagi un missatge OSC-out quan * canviï el missatge d’entrada (sèrie) * És a dir: si girem / premem el botó i canvia de valor. * Per tant, filtrem els valors entrants que realment canvien * nota: no evitarem saltar els valors * ja que provenen, per exemple, d’acceleròmetres o de sensors de distància *, haureu de suavitzar-los vosaltres mateixos a Arduino * / void filterParams () {toSendParams = new HashMap (); for (Clau de cadena: newParams.keySet ()) {// si la clau ja està present si (oldParams.containsKey (key)) {// key present i el valor no és el mateix, actualitzeu if (! oldParams.get (key).equals (newParams.get (key))) {toSendParams.put (key, newParams.get (key)); }} else {// la clau no està present en paràmetres antics, així que poseu-la! toSendParams.put (clau, newParams.get (clau)); } oldParams.put (clau, newParams.get (clau)); }}

voos makeOSC () {

for (Clau de cadena: toSendParams.keySet ()) {OscMessage myMessage = new OscMessage ("/" + key); myMessage.add (toSendParams.get (key)); / * enviar el missatge * / oscP5.send (myMessage, myRemoteLocation); }}

void translateMessage () {

processIncoming (); filterParams (); makeOSC (); } // Quan volem imprimir a la finestra buida ShowIncoming () {// per veure el missatge entrant, tal com s’estableix al text de HashMap ("Incoming from Arduino", 20, 20); int y = 20; per a (Clau de cadena: newParams.keySet ()) {y = y + 20; text (clau, 20, y); text (newParams.get (clau), 300, y); }}

void showOsc () {

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

configuració nul·la () {

mida (1000, 800); // Omplir la mida de l’etapa (255); fons (0); oldParams = nou HashMap (); newParams = nou HashMap (); // printArray (Serial.list ()); commsPort = sèrie nova (this, portName, baudRate);

/ * Inicieu oscP5, escoltant els missatges entrants * /

oscP5 = nou OscP5 (això, listenPort);

/ * myRemoteLocation és una adreça de xarxa. un NetAddress té 2 paràmetres, * una adreça IP i un número de port.myRemoteLocation s’utilitza com a paràmetre a * oscP5.send () quan s’envien paquets osc a un altre ordinador, dispositiu o aplicació *. ús veure més avall. a efectes de prova, el port d'escolta * i el port de l'adreça d'ubicació remota són els mateixos, de manera que * envieu missatges a aquest esbós. * / myRemoteLocation = newAddress Net (IP remot, sendPort); }

sorteig buit () {

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

void serialEvent (Serial commsPort) {

// llegir un byte des del port sèrie: char inChar = commsPort.readChar (); switch (inChar) {caseCaracter contact: commsPort.write (contactCharacter); // demana més println ("començant …"); trencar; case startChar: entrant = ""; trencar; case endChar: messageArrived = true; // println ("final de msg"); trencar; per defecte: entrant + = inChar; trencar; }}

/ * els missatges osc entrants es reenvien al mètode oscEvent. * /

void oscEvent (OscMessage theOscMessage) {valor flotant = theOscMessage.get (0).floatValue (); // obtenir el primer argument osc

IncomingOSCMessage + = "\ n" +

String.format ("### ha rebut un missatge osc:" + "addrpattern:" + theOscMessage.addrPattern () + ":% f", valor); println (IncomingOSCMessage); }

Pas 12: Utilitzeu el controlador

Nu alles is aangesloten, all code is geschreven en alles is gedubbelcheckt is het eindelijk tijd om de controller z'n werk te laten doen. Cerqueu un parell d'efectes a Reaper en genet de voltooide Guitar Hero MIDI Controller!