Guitar Hero Arduino Project: 12 kroków (ze zdjęciami)

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:32

Wij zijn Maarten Vrebos, Justin Cavanas en Wannes Stroobandt en my studenteren 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 był onze bedoeling 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 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.

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/zamień-bohatera-gitara-g…

Benodigdheden voor dit project

• 6 przycisków kleine
• 7 rezystorów 1kohm
• 1 żelowa dioda LED 1
• niebieska dioda LED
• 1 Arduino Uno R3
• 1 zielona dioda LED
• 2 diody LED
• 1 schuifschakelaar
• 1 płytka do krojenia chleba
• 1 potencjometr
• 1 protobord
• 1 Gitara Bohatera Gitary
• Pościel Voldoende
• Materiał do lutowania/dremelen/
• Schroevendraaier

Krok 1: Komponenty Verzamelen

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

6 przycisków

7 rezystorów 1kohm

1 żółta dioda LED

1 niebieska dioda LED

1 Arduino Uno R3

1 zielona dioda LED

2 czerwone diody LED

1 Schuifschakelaar

1 deska do krojenia chleba

1 potencjometr

Krok 2: Prototyp Bouwena

Om ons prototype te bouwen hebben we al onze componenten gebruikt op een breadboard, deze breadboard dient dan als testobject zodat we niet meteen in de behuizing te werk moeten gaan. Dit prototyp 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 éen of meerdere 'snaren' moet worden ingedrukt om een auditief effect te krijgen. De verschillende LED-lampjes dienen gewoon als visuele controle om er zeker van te zijn dat de interactie succesvol werkt.

Krok 3: Prototyp kodu

Zmienne globalne

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 numbers waar mainButton(snaar) en andere buttons aan verbonden zijn:const int mainButton = A1; // gitaar snaar const int lightSensor = A0; const int przyciskPin1 = 2; // nummer van pushbutton1 const int buttonPin2 = 3; // liczba van pushbutton2const int buttonPin3 = 4; // liczba van pushbutton3const int buttonPin4 = 5; // liczba van pushbutton4const int buttonPin5 = 6; // liczba przycisków furgonetki5

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

const int aantalKnoppen = 5;const String namemenKnoppen[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; // numer pinu LED 13

const int ledPin2 = 12; // liczba pinów LED 12 const int ledPin3 = 11; // ilość LED pin 11 const int ledPin4 = 10; // ilość LED pin 10 const int ledPin5 = 9; // ilość diod LED pin 9 const int potPin = A5; // ilość diod LED pin 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 Stanprzycisku1 = 0; int Stan przycisku2 = 0; int Stan przycisku3 = 0; int Stanprzycisku4 = 0; int Stan przycisku5 = 0; int lightSensorState = 0; int potValue = 0; int lightValue = 0;

Ustawiać

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 wat er concreet gedaan wordt. Extra uitleg over wat een specifieke functie concreet doet is te vinden in de arduino reference

void setup() { // szybkość transmisji danych na sekundę (bodów) dla seryjnej transmisji danych Serial.begin(9600); // Inicjalizacja zmiennych ledPin als output pinMode(ledPin1, OUTPUT); pinMode (ledPin2, WYJŚCIE); pinMode (ledPin3, WYJŚCIE); pinMode (ledPin4, WYJŚCIE); pinMode (ledPin5, WYJŚCIE); // inicjalizuj wszystkie przyciski als input: pinMode(mainButton, INPUT); pinMode(przyciskPin1, WEJŚCIE); pinMode(buttonPin2, INPUT); pinMode(przyciskPin3, INPUT); pinMode(przyciskPin4, WEJŚCIE); pinMode(przyciskPin5, INPUT); pinMode(potPin, INPUT); pinMode(lightSensor, INPUT); }

Funkcja unieważnienia

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);

// status wszystkich przycisków w een array

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

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

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

//deklarator w tablicy stanów głównych i geef die de standaard wararden 0 in.

int stany główne = {0, 0, 0, 0, 0};

// pętla nad tablicą aantalKnoppen

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

Krok 4: Prototyp 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 de video jest te zien dat alle knoppen een 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.

Krok 5: 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 originele componenten we eventueel nog zouden kunnen hergebruiken voor onze controller. Uiteindelijk hebben we onze eigen pushbuttons in de bestaande buttons 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 originalele twee buttons gebruikt (zie vierde foto). De LEDjes zullen verdwijnen (deze waren enkel ter indicatie zodat we zagen dat alle knoppen correct werkten.

Krok 6: Werking Originele Buttons + Dremelen

Op de bijhorende video is de wijze te zien waarop de twee originalele 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 originalele knoppen hebben we de binnenkant van de originelen er grotendeels uitgehaald zoals te zien is op de foto.

Krok 7: Pościel Solderen + guziki 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.

Krok 8: Plaats Made in De Behuizing

Omdat dit Guitar Hero-model redelijk krap was om mee te werken hebben we extra plaats moeten maken d.m.v. dremeleny. 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 my w de achterkant van de gitaar een doorgang hebben gecreëerd voor de draden die naar de button 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.

Krok 9: Pościel Aansluiten Op Protobord

Om alle componenten 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 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).

Krok 10: Verstevigen

Als wykończeniem jest het 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.

Krok 11: Kod Voor Het Communiceren Met Reaper

Deze code jest opgedeeld in twee delen, het eerste deel is in de arduino IDE (interaktywne środowisko programistyczne) geschreven. Die code wordt 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.

Przetwarzanie to het tweede gedeelte. Deze code dient om alles wat arduino doortuurt te ontvangen en door te sturen naar Reaper.

Arduino

/* Ten kod jest podstawowym szkicem do komunikacji z Przetwarzaniem przez Serial.

Jest to plan, w którym możesz umieścić swój własny kod

określone dla własnych przycisków, potencjometrów lub czujników.

Ma uścisk dłoni, aby upewnić się, że mamy kontakt

i decydujemy o formacie, w jakim się komunikujemy

Ważne jest, aby w ten sam sposób konstruować przekaz, aby Processing wiedział, jak to zdekonstruować i wysłać prawidłowe komunikaty OSC do naszego DAW

stworzony dla werkcollege AV&IT

paź 2017

*

/szybkość transmisji

const długa szybkość transmisji = 115200;

// czas oczekiwania w ms między odpytywaniem pinów

const int loopPauseTime = 200; // milisekundy

// wartości początkowe i końcowe wiadomości wysyłanej na Serial

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

const char contactCharacter = '|';

// identyfikator pinów

// inne zmienne globalne

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;

// czujniki analogowe

const int potPin = A5; // pin voor tremolo

// Potrzebujemy tej funkcji, aby nawiązać kontakt ze szkicem Przetwarzania

// Zachowaj to tutaj void EstablishContact() { while (Serial.available() <= 0) { Serial.print(contactCharacter); // wyślij znak i czekaj na odpowiedź… delay(loopPauseTime); } Serial.odczyt(); }

pusta konfiguracja () {

// ustaw pinModes dla wszystkich pinów for(int i = 0; i < aantalKnoppen; i++){ pinMode(knopPinnen, INPUT); } pinMode(mainButton, INPUT); // odkomentuj jeśli używasz czujników, które działają na 3V zamiast 5V // będziesz musiał również podłączyć pin 'ext' do 3.3V // analogReference(EXTERNAL);

// zainicjuj komunikację szeregową

Serial.początek(szybkość transmisji); podczas (!Serial); // czekaj na uzgadnianie ustanawiaKontakt(); }

pusta pętla () {

// KROK 1: PRZYCISKI ODCZYTU // odpytywanie wszystkich pinów i mapowanie odczytu na odpowiedni zakres 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); // przykłady: // float v0 = map(bpm, 0, 1023, 60, 250); // jeśli chcesz użyć znormalizowanego float (np. dla objętości) // float v1 = map(analogRead(pin2), fromMin, fromMax, 0, 100) / 100.0;

// KROK 2: NAPISZ WIADOMOŚĆ

Serial.print(startString); // uruchom sekwencję komunikatów for(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(nameKnoppen); Serial.print(", "); Serial.print(buttonStates); if(i < aantalKnoppen - 1){ Serial.print(", "); } } } Serial.print(", "); Serial.print("tremolo"); Serial.print(", "); Serial.print(map(potValue, 0, 1023, 0, 100)); // napisz koniec wiadomości Serial.print(endString);

// Poczekaj chwilę..

opóźnienie (pętlaPauseTime); }

Przetwarzanie

Zastrzeżenie: 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

końcowa szybkość transmisji int = 115200;

// Zoek naar het adres IP w programie Reaper (zie zrzuty ekranu w bijlage)

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

//final String remoteIP = "192.168.1.43"; //np. „127.0.0.1”;

końcowy String remoteIP = "10.3.209.60";

// Zanotuj sendPort i wypełnij go w programie Reaper.

// To jest port, do którego Processing wysyła, a Reaper nasłuchuje.

końcowy port nasłuchu int = 12000, sendPort = 12000;

// ListenPort służy do aktywnego debugowania.

// Nazwy portów również służą do debugowania.

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

końcowy String nazwa_portu = "COM5"; // "/dev/ttyUSB0";

///////////////////// KONIEC PARAMETRÓW UŻYTKOWNIKA ///////////////////////// ////

importowanie przetwarzania.serial.*;

import java.util.*;

importuj oscP5.*;

importuj siećP5.*;

OscP5 OscP5;

NetAddress mojaZdalnaLokalizacja;

Port komunikacji szeregowej; // Port szeregowy

wiadomość logicznaPrzybyła = false;

Ciąg przychodzący = "", IncomingOSCMessage = "";

końcowy znak startChar = '*', endChar = '#'; końcowy znak contactCharacter = '|';

// Aby upewnić się, że wysyłamy tylko parametry (wartości), które się zmieniają

// te globalne zmienne są tutaj zadeklarowane, ale // nie powinny być tutaj inicjowane! HashMap oldParams, newParams, toSendParams;

// Musimy podzielić wiadomość co przecinek

void processIncoming () { String resVec = przychodzące.split(", "); // otrzymujemy pary nazwa + wartość // więc dla każdej nazwy (+2)… try{ for (int i = 0; i< resVec.length; i+=2) { float value = Float.parseFloat(resVec[i+ 1]); // umieść je w nowej tablicy Hashtable newParams.put(resVec, value); } } // jeśli wystąpi błąd, przechwyćmy go i wyjdźmy. catch(Wyjątek ex){ println("Komunikat wyjątku: " + ex); printArray(resVec); Wyjście(); } }

// Aby filtrować nasze wiadomości

/* Upewniamy się, że jest tylko komunikat OSC-out, gdy * zmienia się komunikat wejściowy (Serial) * To znaczy: jeśli przekręcimy/naciśniemy przycisk i zmieni on wartość. * Więc odfiltrowujemy przychodzące wartości, które faktycznie się zmieniają * uwaga: nie unikniemy przeskakiwania wartości * pochodzących np. z akcelerometrów lub czujników odległości * będziesz musiał je wygładzić samodzielnie w Arduino */ void filterParams() { toSendParams = new HashMap(); for (String key: newParams.keySet()) { // jeśli klucz jest już obecny if (oldParams.containsKey(key)) { // klucz obecny i wartość nie jest taka sama, a następnie zaktualizuj if (!oldParams.get(key).equals(noweParams.get(klucz))) { toSendParams.put(klucz, noweParams.get(klucz)); } } else{ // klucz nie występuje w starych parametrach, więc umieść go! toSendParams.put(klucz, noweParams.get(klucz)); } stareParams.put(klucz, noweParams.get(klucz)); } }

void makeOSC() {

for (String key: toSendParams.keySet()) { OscMessage mojaWiadomość = new OscMessage("/"+ klucz); mojaWiadomość.add(toSendParams.get(klucz)); /* wyślij wiadomość */ oscP5.send(mojaWiadomość, mojaZdalnaLokalizacja); } }

void przetłumacz wiadomość() {

procesPrzychodzące(); filtrParametry(); makeOSC(); } // Kiedy chcemy drukować do okna void ShowIncoming() { // aby zobaczyć przychodzącą wiadomość, jak ustawiono w HashMap text("Incoming from Arduino", 20, 20); int y = 20; for (String key: newParams.keySet()) { y = y+20; tekst(klucz, 20, y); text(noweParametry.get(klucz), 300, y); } }

void pokażOsc() {

tekst (Wiadomość przychodząca OSCM, 300, 200); Przychodząca wiadomość OSCM =""; }

pusta konfiguracja () {

rozmiar (1000, 800); // rozmiar stołu montażowego fill(255); tło(0); oldParams = new HashMap(); newParams = new HashMap(); //printArray(Serial.list()); commsPort = new Serial(this, portName, baudRate);

/* uruchom oscP5, nasłuchuj nadchodzących wiadomości */

oscP5 = nowy OscP5(to, listenPort);

/* mojaZdalnaLokalizacja jest adresem sieciowym. NetAddress przyjmuje 2 parametry, * adres IP i numer portu.myRemoteLocation jest używany jako parametr w * oscP5.send() podczas wysyłania pakietów osc do innego komputera, * urządzenia, aplikacji. użycie patrz poniżej. do celów testowych port nasłuchiwania * i port adresu zdalnej lokalizacji są takie same, dlatego * wyślesz wiadomości z powrotem do tego szkicu. */ myRemoteLocation = new NetAddress(zdalnyIP, sendPort); }

nieważne rysowanie () {

if (messageArrived) { background(0); przetłumaczWiadomość(); Pokażprzychodzące(); wiadomośćPrzybyła= fałsz; } showOsc(); }

void serialEvent(Serial commsPort) {

// odczytaj bajt z portu szeregowego: char inChar = commsPort.readChar(); switch (inChar) { case contactCharacter: commsPort.write(contactCharacter); // poproś o więcej println("start…"); przerwa; case startChar: przychodzące= ""; przerwa; case endChar: messageArrived = true; //println("koniec wiadomości"); przerwa; domyślnie: przychodzące += inChar; przerwa; } }

/* przychodzące wiadomości osc są przekazywane do metody oscEvent. */

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

Przychodząca wiadomość OSCM += "\n" +

String.format("### otrzymał komunikat osc: " + " addrpattern: " + theOscMessage.addrPattern() + ": %f", value); println (Komunikat przychodzący OSCM); }

Krok 12: Kontroler Uittesten

Nu alles is aangesloten, alle code is geschreven en alles is gedubbelcheckt is het eindelijk tijd om de controller z'n werk te laten doen. Bezpłatne Zoek można wylewać efekty w Reaper i cieszyć się kontrolerem Guitar Hero MIDI Controller!