Guitar Hero Arduino-Projekt - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:21

Wij zijn Maarten Vrebos, Justin Cavanas und Wannes Stroobandt und wir studieren Multimedia- und Kommunikationstechnologie. Voor een groepsproject voor het vak Audiovisual & IT Principles hebben wij een Guitar Hero-Gitaar gehackt und gebrukt als behuizing voor onze MIDI-Controller. Er war gerade damit beschäftigt, die Besten auf der Gitaar intern und vervangen zu knoppen. Onze controller zal vastgehouden en bespeeld wurde als een normale 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 Papierzien van hoe het eindproduct er zou moeten uitzien met daarnaast een foto van de gitaar sterben 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 Taster
• 7 1kOhm Widerstände
• 1 Gel-LED 1
• blaue LED
• 1 Arduino Uno R3
• 1 grüne LED
• 2 Rod-LEDs
• 1 Schuifschakelaar
• 1 Steckbrett
• 1 Potentiometer
• 1 Prototyp
• 1 Guitar Hero Gitarre
• Voldoende-Bettwäsche
• Material zum Löten/Dremelen/
• Schrövendraaier

Schritt 1: Komponenten Verzamelen

Voor ons Prototyp (op Breadboard) hebben we volgende components gebruikt:

6 Drucktasten

7 1-kOhm-Widerstände

1 gelbe LED

1 blaue LED

1 Arduino Uno R3

1 grüne LED

2 rote LED

1 Schuifschakelaar

1 Steckbrett

1 Potentiometer

Schritt 2: Prototyp Bouwen

Om ons Prototyp te bouwen hebben we al onze Componenten gebruikt op een Breadboard, deze Breadboard dient als Testobjekt zodat wir niet meteen in de behuizing te werk moeten gaan. Dit Prototyp hebben wir dan ok gedigitaliseerd über tinkercad.com, op deze manier hadden wir een duidelijk overzicht van ons Prototyp dat elk groepslid ook kon bewerken.

Er wurde 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 visuelle Kontrolle über zeker van te zijn dat de interactie succesvol werkt.

Schritt 3: Code-Prototyp

Globale Variablen

In het eerste deel van de code initialiseer je global variabelen voor de pin van arduino uno waar all pushbuttons mee verbonden zijn.

// zet Pin-Nummern waar mainButton(snaar) und andere Tasten aan verbonden zijn:const int mainButton = A1; // Gitaar Snaar Const Int LightSensor = A0; const int buttonPin1 = 2; // Nummer von pushbutton1 const int buttonPin2 = 3; // Nummer von pushbutton2const int buttonPin3 = 4; // Nummer von pushbutton3const int buttonPin4 = 5; // Nummer von pushbutton4const int buttonPin5 = 6; // nummer van pushbutton5

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

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

En dan nog variabelen voor de pin van de LED-Lichtjes.

const int ledPin1 = 13; // die Nummer des LED-Pins 13

const int ledPin2 = 12; // die Anzahl der LED-Pins 12 const int ledPin3 = 11; // die Anzahl der LED-Pins 11 const int ledPin4 = 10; // die Anzahl der LED-Pins 10 const int ledPin5 = 9; // die Anzahl der LED-Pins 9 const int potPin = A5; // die Anzahl der LED-Pins A5

De laatste globale variabelen dienen als 'States' voor de Sensoren (zijn de Taster ingedrukt von niet? Potentiometer, Lichtsensor).

// initialisiere 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 Lichtwert = 0;

Aufstellen

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

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

Void setup () {// Datenrate pro Sekunde (Baud) für serielle Datenübertragung Serial.begin (9600); // Initialisiere de ledPin variabelen als Ausgang pinMode(ledPin1, OUTPUT); pinMode (ledPin2, AUSGANG); pinMode (ledPin3, AUSGANG); pinMode (ledPin4, AUSGANG); pinMode (ledPin5, AUSGANG); // alle Taster als Input initialisieren: pinMode(mainButton, INPUT); pinMode (buttonPin1, INPUT); pinMode (buttonPin2, INPUT); pinMode (buttonPin3, INPUT); pinMode (buttonPin4, INPUT); pinMode (buttonPin5, INPUT); pinMode (potPin, EINGANG); pinMode (Lichtsensor, EINGANG); }

Leerfunktion

Na de setup() functie volgt de loop() functie, de instructies sterben 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 Drucktastenstatus in einem Array

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

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

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

// Deklarator een Array mainStates en geef die de standaard waarden 0 in.

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

// Schleife über das Array aantalKnoppen

for(int i = 0; i < aantalKnoppen; i++){ pinMode(knopPinnen, INPUT); // Initialisiere 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); } }

Schritt 4: Prototyp Uittesten

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

In de tweede video ist te zien hoe onze tremolo werkt aan de hand van een potentiometer in de gitaar und hoe de waardes wurde in Processing uitgelezen.

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

Als de code correct werkte op het Prototyp zijn haben wir het "ontmantelen" van onze Guitar Hero-gitaar kennengelernt. Wir hebben de gitaar opengemaakt met een schroevendraaier en bekeken welke originele componenten we eventueel nog touden kunnen hergebruiken voor onze controller. Uiteindelijk hebben wir onze eigen Druckknöpfe in de bestaande Knöpfe gekregen (zie volgende stap). Wir hebben de tremolo ook gebruikt voor ons eindproduct en voor onze hoofdbutton (initiële button om as 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.

Schritt 6: Originele-Tasten + Dremelen bearbeiten

Op de bijhorende video is de wijze te zien waarop de twee originele knoppen werken as aen soort van schakelaar the 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.

Schritt 7: Bedrading Solderen + Knöpfe Vastlijmen

Omdat we niet meer met een Breadboard werken moeten de draden gesoldeerd worden om zo de verschillende components 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.

Schritt 8: Plaats Maken in 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 sterben 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 mit der Arduino-Tür und dem gat in de onderkant van de gitaar de behuizing verlaten.

Schritt 9: Bedrading Aansluiten Op Protobord

Om alle Komponenten mit elkaar te verbinden hebben we gebruik gemaakt van een protobord. Dies ist ein bordje dat eigenlijk op net dezelfde manier werkt as een bordbord, maar dan betrouwbaarder en efficiënter. Wir 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).

Schritt 10: Verstevigen

Der letzte Schliff ist der 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 mit stukjes karton.

Schritt 11: Code Voor Het Communiceren Met Reaper

Deze-Code ist in twee delen opgedeeld, het eerste deel ist in de arduino IDE (interactive development enviroment) geschreven. Die code wordt geüpload naar arduino zelf en dient om alle waarden van de sensoren van de midi controller uit te lezen en door te sturen naar processing.

Die Verarbeitung ist het tweede gedeelte. Deze code dient alles wat arduino Doorstuurt te ontvangen und Door te sturen naar Reaper.

Arduino

/* Dieser Code ist eine grundlegende Skizze für die Kommunikation mit Processing über Serial.

Es ist eine Blaupause, in die Sie Ihren eigenen Code einfügen können

für eigene Taster, Potentiometer oder Sensoren spezifiziert.

Es hat einen Handschlag, um sicherzustellen, dass wir Kontakt haben

und das Format, in dem wir kommunizieren, steht fest

Es ist wichtig, die Nachricht auf die gleiche Weise zu konstruieren, damit Processing weiß, wie man es dekonstruiert und korrekte OSC-Nachrichten an unsere DAW sendet

gemacht für werkcollege AV&IT

Oktober 2017

*

/ Baudrate

const lange BaudRate = 115200;

// Wartezeit in ms zwischen den Abfragen der Pins

const int loopPauseTime = 200; // Millisekunden

// Start- und Endwerte für die auf Serial gesendete Nachricht

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

const char contactCharacter = '|';

// Pin-IDs

// andere globale Variablen

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

int mainButtonState = 0;

int potValue = 0;

// analoge Sensoren

const int potPin = A5; // Pin für Tremolo

// Diese Funktion benötigen wir, um Kontakt mit der Processing-Skizze aufzunehmen

// Halten Sie es hier Void EstablishContact () { Während (Serial.available () <= 0) {Serial.print (contactCharacter); // ein Zeichen senden und auf eine Antwort warten… delay(loopPauseTime); } Serial.read(); }

Leere Einrichtung () {

// setze die pinModes für alle Pins for(int i = 0; i <aantalKnoppen; i++) { pinMode(knopPinnen, INPUT); } pinMode (mainButton, INPUT); // kommentieren Sie, wenn Sie Sensoren verwenden, die mit 3 V anstelle von 5 V arbeiten // Sie müssen den "ext" -Pin auch mit 3,3 V verbinden // analogReference (EXTERNAL);

// Serielle Kommunikation initialisieren

Serial.begin (baudRate); while (!Seriell); // Warte auf Handshake EstablishContact(); }

Leere Schleife () {

// SCHRITT 1: READ BUTTONS // alle Pins abfragen und den Messwert dem entsprechenden Bereich zuordnen 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); // Beispiele: // float v0 = map(bpm, 0, 1023, 60, 250); // wenn Sie einen normalisierten Float verwenden möchten (zB für Volumen) // float v1 = map(analogRead(pin2), fromMin, fromMax, 0, 100) / 100.0;

// SCHRITT 2: NACHRICHT SCHREIBEN

Serial.print (startString); // eine Nachrichtensequenz starten for(int i = 0; i <aantalKnoppen; i++) { if (mainButtonState == HIGH) { Serial.print (namenKnoppen); Serial.print (", "); Serial.print (buttonStates); Wenn (ich <aantalKnoppen - 1) {Serial.print (", "); }} sonst { buttonStates = 0; Serial.print (namenKnoppen); Serial.print (", "); Serial.print (buttonStates); Wenn (ich <aantalKnoppen - 1) {Serial.print (", "); } } } Serial.print (", "); Serial.print ("tremolo"); Serial.print (", "); Serial.print (map (potValue, 0, 1023, 0, 100)); // Schreiben Sie das Ende der Nachricht Serial.print (endString);

// warten Sie eine Weile..

Verzögerung (SchleifePauseTime); }

wird bearbeitet

Haftungsausschluss: Niet alle 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

finale int BaudRate = 115200;

// Zoek naar het IP-Adresse in Reaper (siehe Screenshots in Bijlage)

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

//letzter String remoteIP = "192.168.1.43"; //z. B. "127.0.0.1";

final String remoteIP = "10.3.209.60";

// Notieren Sie sich den sendPort und tragen Sie diesen in Reaper ein.

// Dies ist der Port, an den Processing sendet und auf den Reaper lauscht.

final int listenPort = 12000, sendPort = 12000;

// Der listenPort hier dient zum aktiven Debuggen.

// die portNames sind auch zum debuggen da.

//final String portName = "/dev/ttyACM0";

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

///////////////////// ENDE BENUTZERPARAMETER ///////////////////////// ////

Importabwicklung.seriell.*;

java.util.* importieren;

oscP5.* importieren;

importieren netP5.*;

OscP5 oscP5;

NetAddress myRemoteLocation;

Serieller Kommunikationsanschluss; // Die serielle Schnittstelle

boolesche NachrichtArrived = false;

String eingehend = "", IncomingOSCMessage = "";

letztes Zeichen startChar = '*', endChar = '#'; letztes Zeichen contactCharacter = '|';

// Um sicherzustellen, dass wir nur die Parameter (Werte) senden, die sich ändern

// diese globalen Variablen werden hier gelöscht, sollten aber // hier nicht initialisiert werden! HashMap oldParams, newParams, toSendParams;

// Wir müssen die Nachricht bei jedem Komma trennen

void processIncoming () { String resVec = eingehend.split(", "); // wir erhalten Name + Wert-Paare // also für jeden Namen (+2)… try{ for (int i = 0; i< resVec.length; i+=2) { float value = Float.parseFloat(resVec[i+ 1]); // lege sie in die neue Hashtable newParams.put(resVec, value); } } // Wenn ein Fehler auftritt, fangen wir ihn ab und beenden ihn. catch(Ausnahme ex){ println("Ausnahmemeldung: " + ex); printArray(resVec); Ausfahrt(); } }

// Um unsere Nachrichten zu filtern

/* Wir stellen sicher, dass es nur eine OSC-out-Nachricht gibt, wenn * sich die Eingabenachricht (Serial) ändert * Das heißt: wenn wir den Knopf drehen/drücken und er den Wert ändert. * Also filtern wir die eingehenden Werte heraus, die sich tatsächlich ändern * Hinweis: Wir werden nicht springende Werte vermeiden * wie sie zB von Beschleunigungsmessern oder Distanzsensoren kommen * diese müssen Sie in Arduino selbst glätten */ void filterParams () { toSendParams = new HashMap(); for (String key: newParams.keySet()) { // wenn der Schlüssel bereits vorhanden ist if (oldParams.containsKey(key)) { // Schlüssel vorhanden und Wert nicht gleich, dann update if (!oldParams.get(key).equals(newParams.get(key))) { toSendParams.put(key, newParams.get(key)); } } else{ // Schlüssel ist in alten Parametern nicht vorhanden, also sag es! toSendParams.put(key, newParams.get(key)); } oldParams.put(key, newParams.get(key)); } }

void makeOSC() {

for (String key: toSendParams.keySet()) { OscMessage myMessage = new OscMessage("/"+ key); myMessage.add(toSendParams.get(key)); /* Nachricht senden */ oscP5.send(myMessage, myRemoteLocation); } }

void translateMessage() {

processIncoming(); filterParams(); makeOSC(); } // Wenn wir in das Fenster drucken möchten void ShowIncoming () { // um eingehende Nachrichten zu sehen, wie in der HashMap-Text festgelegt ("Incoming from Arduino", 20, 20); int y = 20; for (String key: newParams.keySet()) { y = y+20; text(Taste, 20, y); text(newParams.get(key), 300, y); } }

void showOsc() {

text(Eingehende OSC-Nachricht, 300, 200); IncomingOSCMessage =""; }

Leere Einrichtung () {

Größe (1000, 800); // Bühnengröße füllen (255); Hintergrund(0); oldParams = new HashMap(); newParams = new HashMap(); //printArray(Serial.list()); commsPort = new Serial(this, portName, baudRate);

/* oscP5 starten, auf eingehende Nachrichten lauschen */

oscP5 = neuer OscP5 (dieser, listenPort);

/* myRemoteLocation ist eine NetAddress. eine NetAddress benötigt 2 Parameter, * eine IP-Adresse und eine Portnummer.myRemoteLocation wird als Parameter in * oscP5.send() verwendet, wenn osc-Pakete an einen anderen Computer, ein Gerät oder eine Anwendung * gesendet werden. Nutzung siehe unten. zu Testzwecken sind der Listening-Port * und der Port der Remote-Standort-Adresse identisch, daher werden Sie * Nachrichten an diesen Sketch zurücksenden. */ myRemoteLocation = new NetAddress(remoteIP, sendPort); }

Leere zeichnen () {

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

void serialEvent(Serieller commsPort) {

// ein Byte vom seriellen Port lesen: char inChar = commsPort.readChar(); switch (inChar) { case contactCharacter: commsPort.write (contactCharacter); // nach mehr fragen println("beginnend…"); brechen; case startChar: eingehend= ""; brechen; case endChar: messageArrived = true; //println("Ende der Nachricht"); brechen; Standard: eingehend += inChar; brechen; } }

/* eingehende osc-Nachrichten werden an die oscEvent-Methode weitergeleitet. */

void oscEvent (OscMessage theOscMessage) { float value = theOscMessage.get(0).floatValue(); // Hole das erste osc-Argument

Eingehende OSC-Nachricht += "\n" +

String.format("### hat eine osc-Nachricht erhalten: " + " addrpattern: " + theOscMessage.addrPattern() + ": %f", value); println(IncomingOSCMessage); }

Schritt 12: Controller Uittesten

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. Ein paar weniger Effekte auf Reaper und Genie des Voltoide Guitar Hero MIDI Controllers!