Guitar Hero Arduino Project: 12 steg (med bilder)

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:46

Vi är Maarten Vrebos, Justin Cavanas och Wannes Stroobandt och vi studerar multimedia och kommunikationsteknik. För ett gruppsprojekt för det audiovisuella & IT-principerna har vi en Guitar Hero-gitaar som kan användas och användas för att bearbeta vår MIDI-controller. Det var vår mening om de befintliga knapparna på gitaren för att ersätta. Våra kontroller kommer att bli stora och sparas som en vanlig gitarr. Vi behöver inte ha något extra material att behöva verka.

I bilden kan du använda våra allmänna schets för att se hur pappersprodukten skulle sluta att vi också skulle kunna se en bild av den som skulle användas för att bearbeta.

Vi har för detta projekt baserat på följande 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 små tryckknappar
• 7 1kohm motstånd
• 1 gele LED 1
• blå LED
• 1 Arduino Uno R3
• 1 grön LED
• 2 red -lysdioder
• 1 schuifschakelaar
• 1 brödbräda
• 1 potentiometer
• 1 protobord
• 1 Guitar Hero gitaar
• Voldoende sängklass
• Material om te solderen/dremelen/
• Schroevendraaier

Steg 1: Componenten Verzamelen

För vår prototyp (på brödbräda) har vi följande komponenter som används:

6 tryckknappar

7 1kohm motstånd

1 gul lysdiod

1 blå LED

1 Arduino Uno R3

1 grön lysdiod

2 Röd LED

1 Schuifschakelaar

1 brödbräda

1 Potentiometer

Steg 2: Prototyp Bouwen

Om vår prototyp att bygga har vi alla våra komponenter som används på ett brödbräda, detta brödbräda kan användas och som testobjekt så att vi inte kan använda det för att kunna arbeta. Den här prototypen har vi också kunnat digitalisera via tinkercad.com, på denna sätt hade vi en tydlig överblick över vår prototyp som alla grupper kan använda också.

Det finns 5 små tryckknappar som används för att fungera som 5 snaren och en stor tryckknapp som kan kombineras med en eller flera 'snaren' måste användas för att få en auditiv effekt. De olika LED-lamporna kan bara användas som visuell kontroll för att säkerställa att den interaktiva framgången fungerar.

Steg 3: Kodprototyp

Globale variabelen

I den första delen av koden initialiserar du globala variabler för de stift av arduino där alla tryckknappar är förbundna.

// zet pin numbers waar mainButton (snaar) och andra knappar till verbonden är: 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 tryckknapp5

Här kommer två matriser att användas för namnen på tryckknapparna och har en pinnummer.

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

En annan variabel för LED -lampor.

const int ledPin1 = 13; // numret på LED -stiftet 13

const int ledPin2 = 12; // antalet LED -stift 12 const int ledPin3 = 11; // antalet LED -stift 11 const int ledPin4 = 10; // antalet LED -stift 10 const int ledPin5 = 9; // antalet LED -stift 9 const int potPin = A5; // antalet LED -stift A5

De laatste globala variabelen dienen som 'tillstånd' för sensorer (de tryckknappar som ingår i inte? Potentiometer, lichtsensor).

// initialize 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;

Uppstart

Nu följer de void installationsfunktionen. Denna är av typen void (ger ingen värde tillbaka) och instruktionerna här kan bara utföras en gång.

Vid varje funktion är kommentaren skriven vad som är konkret gjort. Extra bra över vad en särskild funktion konkret gör är att hitta i den arduino referensen

void setup () {// datahastighet per sekund (baud) för seriell dataöverföring Serial.begin (9600); // Initialize de ledPin variabelen as output pinMode (ledPin1, OUTPUT); pinMode (ledPin2, OUTPUT); pinMode (ledPin3, OUTPUT); pinMode (ledPin4, OUTPUT); pinMode (ledPin5, OUTPUT); // initialisera alla tryckknappar som 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); }

Ogiltig funktion

Efter installationen () fungerar följande loop () -funktion, de instruktioner som här kommer att bli genomförda.

void loop () {// läs de stat av de tryckknappar ut (ingedrukt of niet) mainButtonState = digitalRead (mainButton); buttonState1 = digitalRead (buttonPin1); buttonState2 = digitalRead (buttonPin2); buttonState3 = digitalRead (buttonPin3); buttonState4 = digitalRead (buttonPin4); buttonState5 = digitalRead (buttonPin5);

// alla tryckknappstatuser i en array

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

// läst värde från en potentiometer och en lichtsensor

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

// förklarar en array mainStates och geef som standardvärdet 0 tum.

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

// loop over de array antalKnoppen

for (int i = 0; i <antalKnoppen; i ++) {pinMode (knopPinnen , INPUT); // initialize all knopPinnen as input digitalRead (knopPinnen ); // läs de värde av alla knoppinnen uit // indien de mainswitch (snaar) ingedrukt is, print alle knopnamen, all buttonstates if (mainButtonState == HIGH) {Serial.print (namenKnoppen ); Serial.print (","); Serial.println (buttonStates ); }}

Steg 4: Prototyp Uittesten

Efter att prototypen är uppbyggd enligt modellen och kodens kod är i bearbetning, är det dags för prototypen att testa. På videon kan vi se att alla knoppar en reaktion ger möjlighet att kombinera ledningar och att även kombinationer av knappar är möjliga.

I den andra videon kan vi se hur vår tremolo fungerar för att hantera en potentiometer i gitaren och hur de kan bli utgivna i bearbetning.

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

Om vi använder koden för att fungera på prototypen kan vi börja med att skapa sina "gitarrhjältar". Vi har en öppning som kan användas med en schroevendraaier och bekämpa vilka ursprungliga komponenter vi eventuellt inte kan använda för vår styrenhet. Vi har vanligtvis våra egna tryckknappar i de befintliga knapparna som finns (se följande stap). Vi har också använt tremolo för vår slutprodukt och för vår huvudknapp (initial knapp för en kombination av spel) och vi har också använt de två andra knapparna (se fyra bilder). De LED -skivor kommer att fungera (dessa var enkla indikationer så att vi kan använda alla korrekta funktioner).

Steg 6: Arbeta Originele -knappar + Dremelen

På den vidhäftande videon kan vi se hur de två ursprungliga knapparna fungerar som en typ av schakelare som vi kan använda för att skapa en effekt för att kombinera knoppen.

Om våra egna knappar kan verifieras i de ursprungliga knapparna har vi inomhuskant av de ursprungliga delarna som vi kan se på bilden.

Steg 7: Bedrading Solderen + Knappar Vastlijmen

Eftersom vi inte behöver mer än ett brödbräda måste vi ladda ner dem för att dela olika komponenter med varandra. Efter att detta kan göras kan vi visa knappar som att se bilder. Eens dit gebeurd can we wegaangaan to the following stap.

Steg 8: Plattor gjorda i De Behuizing

Eftersom detta gitarr hjälte-modell redelijk krap var om jag skulle kunna arbeta har vi extra plats måste göra d.m.v. dremelen. Så vi har tagit bort en bakre del av gitaren så att vi kan ta bort en plats där du kan placera platsen för bedrading i gitaar. Eftersom det finns en övergripande inriktning på de inre obstaklarna, kan vi också ta bort optimalt av de givna utrymmena vi kan använda. Op de vierde och femde foto är att se att vi i den bakre delen av gitaren en dörr har kontrollerat för de knappar som kommer till knapparna kommer eftersom de gitaar annars inte mer att sluta var. En av de sista bilderna kommer att se att vi kan använda den direkta verbonen med Arduino -dörren till en gat i en kant av den gitaar som hanterar förlorade.

Steg 9: Bedrading Aansluiten Op Protobord

Om alla komponenter med varandra kan vi använda en protobord. Detta är ett bord som har en egen funktion på samma sätt som ett brödbord, men det är en bra och effektiv matlagning. Vi har bedrading till det bordje gesoldeerd som att se är på tredje foto. Detta bord är en central punkt där alla våra förbindelser och sammankomster samlas (se foto 2).

Steg 10: Verstevigen

Som avslutning är det mycket viktigt att du kan förstärka extra stabilitet. På detta foto kan vi se hur vi har delat att vi har uthämtat d.m.v. dremelen achteraan de buttons verstevigen with piecesjes karton.

Steg 11: Code Voor Het Communiceren Met Reaper

Denna kod är inmatad i två delar, den första delen är inbyggd i IDE (interaktivt utvecklingsmiljö). Koden kommer att laddas upp för att du själv ska kunna använda alla sensorer och midi -styrenheter för att kunna bearbeta.

Bearbetning är den andra delen. Denna kod måste innehålla allt som arduino -dörrstorleken tar emot och skickar dörrar till Reaper.

Arduino

/* Denna kod är en grundläggande skiss för att kommunicera med Processing through Serial.

Det är en ritning där du kan lägga din egen kod

specificerad för dina egna knappar, potentiometrar eller sensorer.

Den har ett handslag för att se till att vi har kontakt

och det format som vi kommunicerar i bestäms

Det är viktigt att konstruera budskapet på samma sätt, så att Processing vet hur man dekonstruerar det och skickar rätt OSC-meddelanden till vår DAW

gjord för werkcollege AV&IT

oktober 2017

*

/ överföringshastighet

const long baudRate = 115200;

// tid att vänta i ms mellan omröstningar till stiften

const int loopPauseTime = 200; // milli sekunder

// start- och slutvärden för meddelandet som skickas på Serial

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

const char contactCharacter = '|';

// pin -id

// andra globala variabler

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

int mainButtonState = 0;

int potValue = 0;

// analoga sensorer

const int potPin = A5; // pin voor tremolo

// Vi behöver denna funktion för att skapa kontakt med bearbetningsskissen

// Behåll det här void etablContact () {while (Serial.available () <= 0) {Serial.print (contactCharacter); // skicka en char och vänta på svar … fördröjning (loopPauseTime); } Serial.read (); }

void setup () {

// ställ in pinModes för alla stiften för (int i = 0; i <antalKnoppen; i ++) {pinMode (knopPinnen , INPUT); } pinMode (mainButton, INPUT); // okommentera om du använder sensorer som fungerar på 3V istället för 5V // du måste också koppla 'ext' -pinnen till 3.3V // analogReference (EXTERNAL);

// initiera seriekommandon

Serial.begin (baudRate); medan (! Seriell); // vänta på handskakning upprättaContact (); }

void loop () {

// STEG 1: LÄS KNAPPAR // polla alla stiften och mappa avläsningen till lämpligt intervall int buttonStates [antalKnoppen]; /* 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 <antalKnoppen; i ++) {buttonStates = digitalRead (knopPinnen ); } potValue = analogRead (potPin); // exempel: // float v0 = map (bpm, 0, 1023, 60, 250); // om du vill använda en normaliserad float (t.ex. för volym) // float v1 = map (analogRead (pin2), fromMin, fromMax, 0, 100) / 100.0;

// STEG 2: SKRIV MEDDELANDE

Serial.print (startString); // starta en meddelandesekvens för (int i = 0; i <antalKnoppen; i ++) {if (mainButtonState == HIGH) {Serial.print (namenKnoppen ); Serial.print (","); Serial.print (buttonStates ); if (i <antalKnoppen - 1) {Serial.print (","); }} else {buttonStates = 0; Serial.print (namenKnoppen ); Serial.print (","); Serial.print (buttonStates ); if (i <antalKnoppen - 1) {Serial.print (","); }}} Serial.print (","); Serial.print ("tremolo"); Serial.print (","); Serial.print (map (potValue, 0, 1023, 0, 100)); // skriv slutet av meddelandet Serial.print (endString);

// vänta ett tag..

delay (loopPauseTime); }

Bearbetning

Friskrivningsklausul: Inte alla koder för bearbetning av skisser står här i skriften, för den fullständiga koden se filen: ProcessingSoundControl_handout_v6_1.pde i bijlage

Följande instruktioner måste tillämpas:

// Baudrate måste samma vara liknande i arduino -skissen

final int baudRate = 115200;

// Sök efter IP -adressen i reaper (se skärmdumpar i bijlage)

// Behandlar skicka till detta andres och reaper lyssna här //

// final String remoteIP = "192.168.1.43"; //t.ex. "127.0.0.1";

final String remoteIP = "10.3.209.60";

// Notera sendPort och fyll i detta i Reaper.

// Detta är porten Processing skickar till och Reaper lyssnar på.

final int listenPort = 12000, sendPort = 12000;

// ListenPort här är för att aktivt felsöka.

// portnamnen är också här för att felsöka.

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

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

/////////////////////// END OF USER PARAMETERS ///////////////////////// ////

import bearbetning. serie.*;

importera java.util.*;

importera oscP5.*;

importera netP5.*;

OscP5 oscP5;

NetAddress myRemoteLocation;

Seriell commsPort; // Seriell port

booleskt meddelandeArrived = false;

Sträng inkommande = "", IncomingOSCMessage = "";

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

// För att vara säker på att vi bara skickar de parametrar (värden) som ändras

// dessa globala variabler delcared här men ska // inte initialiseras här! HashMap oldParams, newParams, toSendParams;

// Vi måste dela meddelandet vid varje kommatecken

void processIncoming () {String resVec = incoming.split (","); // vi får namn+värdepar // så för varje namn (+2) … försök {för (int i = 0; i <resVec.length; i+= 2) {float value = Float.parseFloat (resVec [i+ 1]); // lägg dem i den nya Hashtable newParams.put (resVec , värde); }} // om ett fel uppstår, låt oss få det att visas och avsluta. catch (Undantag ex) {println ("Undantagsmeddelande:" + ex); printArray (resVec); utgång(); }}

// För att filtrera våra meddelanden

/ * Vi ser till att det bara finns ett OSC-ut-meddelande när * inmatningsmeddelandet (seriellt) ändras * Det vill säga: om vi vrider/trycker på knappen och det ändrar värde. * Så vi filtrerar bort de inkommande värden som faktiskt ändras * Obs: vi kommer inte att undvika hoppvärden * som kommer från t.ex. accelerometrar eller distanssensorer * du måste själv jämna ut dem i Arduino */ void filterParams () {toSendParams = new HashMap (); för (String key: newParams.keySet ()) {// om nyckeln redan finns om (oldParams.containsKey (key)) {// key present and value not the same, update then if (! oldParams.get (key).equals (newParams.get (key))) {toSendParams.put (key, newParams.get (key)); }} else {// nyckel finns inte i gamla params, så säg det! toSendParams.put (key, newParams.get (key)); } oldParams.put (nyckel, newParams.get (nyckel)); }}

void makeOSC () {

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

void translateMessage () {

processIncoming (); filterParams (); makeOSC (); } // När vi vill skriva ut till fönstret ogiltiga ShowIncoming () {// för att se inkommande meddelande, som anges i HashMap -texten ("Inkommande från Arduino", 20, 20); int y = 20; för (String key: newParams.keySet ()) {y = y+20; text (nyckel, 20, y); text (newParams.get (key), 300, y); }}

void showOsc () {

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

void setup () {

storlek (1000, 800); // Scenstorlek fyllning (255); bakgrund (0); oldParams = new HashMap (); newParams = ny HashMap (); // printArray (Serial.list ()); commsPort = new Serial (this, portName, baudRate);

/ * starta oscP5, lyssna på inkommande meddelanden */

oscP5 = ny OscP5 (detta, listenPort);

/* myRemoteLocation är en NetAddress. en NetAddress tar två parametrar, * en ip -adress och ett portnummer.myRemoteLocation används som parameter i * oscP5.send () när osc -paket skickas till en annan dator, enhet, * applikation. användning se nedan. för teständamål är lyssningsporten * och porten på fjärradressen desamma, därför kommer du * att skicka meddelanden tillbaka till denna skiss. */ myRemoteLocation = ny NetAddress (remoteIP, sendPort); }

void draw () {

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

void serialEvent (Serial commsPort) {

// läs en byte från serieporten: char inChar = commsPort.readChar (); switch (inChar) {case contactCharacter: commsPort.write (contactCharacter); // be om mer println ("börjar …"); ha sönder; case startChar: inkommande = ""; ha sönder; case endChar: messageArrived = true; // println ("slutet av meddelandet"); ha sönder; standard: inkommande += inChar; ha sönder; }}

/* inkommande osc -meddelande vidarebefordras till oscEvent -metoden. */

void oscEvent (OscMessage theOscMessage) {float value = theOscMessage.get (0).floatValue (); // få det första osc -argumentet

IncomingOSCMessage += "\ n" +

String.format ("### fick ett osc -meddelande:" + "addrpattern:" + theOscMessage.addrPattern () + ": %f", värde); println (IncomingOSCMessage); }

Steg 12: Controller Uittesten

Nu är allt angesloten, alla koder är skrivna och allt är gedubbelcheckt är den slutliga tiden för styrenheten för att kunna göra något. Hitta ett par roliga effekter på Reaper och njut av voltooide Guitar Hero MIDI Controller!