Guitar Hero Arduino Project: 12 trin (med billeder)

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:29

Vi er Maarten Vrebos, Justin Cavanas og Wannes Stroobandt og vi studerer multimedie- og kommunikationsteknologi. For et gruppeprojekt for det audiovisuelle og IT-princip har vi en Guitar Hero-gitaar, der kan bruges og bruges som behandling til vores MIDI-controller. Det var vores hensigt om de eksisterende knapper på den gitaar praktikant at erstatte. Vores controller vil blive opbevaret og vist som en normal gitaar. Vi har ikke noget, vi har hørt, men vi har ikke meget ekstra materiale, der skal verificeres.

I billedet kan du bruge vores almindelige skitser til papir, som kan se, hvordan det endelige produkt skulle blive brugt til senere at se et foto af gitaren, der også vil blive brugt.

Vi har et projekt baseret på følgende 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å trykknapper
• 7 1kohm modstande
• 1 gele LED 1
• blå LED
• 1 Arduino Uno R3
• 1 groene LED
• 2 rode LED'er
• 1 schuifschakelaar
• 1 brødbræt
• 1 potentiometer
• 1 protobord
• 1 Guitar Hero gitaar
• Voldoende sengetøj
• Materiale til solderen/dremelen/
• Schroevendraaier

Trin 1: Componenten Verzamelen

Til vores prototype (på brødbræt) har vi følgende komponenter brugt:

6 trykknapper

7 1kohm modstande

1 gul LED

1 Blå LED

1 Arduino Uno R3

1 grøn LED

2 Rød LED

1 Schuifschakelaar

1 brødbræt

1 Potentiometer

Trin 2: Prototype Bouwen

Om vores prototype til opbygning har vi alle vores komponenter brugt på et brødbræt, dette brødbræt skal kunne bruges som testobjekt, så vi ikke kan meten til at behandle arbejdet. Denne prototype har vi også kunnet digitalisere via tinkercad.com, på denne måde havde vi et klart overblik over vores prototype, som alle grupper også kan arbejde på.

Der bruges 5 små trykknapper, der bruges som 5 snaren og en stor trykknap, der kan kombineres med én eller flere 'snaren', skal bruges til at få en auditiv effekt. De forskellige LED-lamper kan normalt også bruges til at kontrollere, om det er sikkert, at den interaktive succes fungerer.

Trin 3: Kodeprototype

Globale variabler

I den første del af koden initialiseres globale variationer for de stifter af arduino, hvor alle trykknapper kan bruges.

// zet pin numbers waar mainButton (snaar) og andre knapper til verbonden er: const int mainButton = A1; // gitaar snaar const int lightSensor = A0; const int buttonPin1 = 2; // nummer af trykknap1 const int buttonPin2 = 3; // nummer af pushbutton2const int buttonPin3 = 4; // nummer af pushbutton3const int buttonPin4 = 5; // nummer af pushbutton4const int buttonPin5 = 6; // nummer af trykknap5

Her er der to arrays, der kan bruges til at navngive trykknapper og 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 anden variabel til de pins af LED -lysene.

const int ledPin1 = 13; // nummeret på LED -stiften 13

const int ledPin2 = 12; // antallet af LED pin 12 const int ledPin3 = 11; // antallet af LED pin 11 const int ledPin4 = 10; // antallet af LED pin 10 const int ledPin5 = 9; // antallet af LED pin 9 const int potPin = A5; // antallet af LED pin A5

De sidste globale variabelen dienen som 'tilstande' for sensorer (hans trykknapper er indbyggede af ikke? 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;

Opsætning

Nu følger de ugyldige installationsfunktioner. Denne er af typen ugyldig (giver ingen værdi tilbage) og instruktionerne bliver her kun 1 gang udført.

Ved enhver funktion er kommentaren skrevet, hvad der er konkret gjort. Ekstra ud over, hvad en særlig funktion konkret gør, er at finde i den arduino reference

void setup () {// datahastighed pr. sekonde (baud) for seriel dataoverførsel Serial.begin (9600); // Initialiser de ledPin -variabler som output pinMode (ledPin1, OUTPUT); pinMode (ledPin2, OUTPUT); pinMode (ledPin3, OUTPUT); pinMode (ledPin4, OUTPUT); pinMode (ledPin5, OUTPUT); // initialiser alle trykknapper 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); }

Ugyldig funktion

Efter opsætning () funktion følger loop () funktion, de instruktioner, der kan stå for at blive udført.

void loop () {// læs de stat af de trykknapper ud (ingedrukt of niet) mainButtonState = digitalRead (mainButton); buttonState1 = digitalRead (buttonPin1); buttonState2 = digitalRead (buttonPin2); buttonState3 = digitalRead (buttonPin3); buttonState4 = digitalRead (buttonPin4); buttonState5 = digitalRead (buttonPin5);

// alle trykknapstatus i et array

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

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

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

// erklærer en array mainStates og giver standard standardværdier 0 in.

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

// loop over de array antalKnoppen

for (int i = 0; i <antalKnoppen; i ++) {pinMode (knopPinnen , INPUT); // initialiser alle knopPinnen som input digitalRead (knopPinnen ); // læs de værdi af 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 ); }}

Trin 4: Prototype Uittesten

Efter at prototypen blev opbygget, er den efter vores model og den kode, der er skrevet i behandling, er det tid til prototypen, der skal testes. På videoen kan du se, at alle knapperne reagerer på, at vi kan kombinere og kombinere forskellige funktioner.

I den anden video kan vi se, hvordan vores tremolo fungerer ved hånden af et potentiometer i gitaren, og hvordan de blev udgivet i behandling.

Trin 5: Behuizing "ontmantelen" En Kijken Hvilke Componenten Gebruikt Gaan Worden

Når vi koder korrekt til prototypen, begynder vi med at "konstruere" vores Guitar Hero-gitaar. Vi har en gitaar, der kan bruges til en skråførende maskine og kende, hvilke originale komponenter vi eventuelt kan bruge til at bruge vores controller. Vi har vores egne trykknapper i de eksisterende knapper, der er registreret (se følgende stap). Vi har også brugt den tremolo til vores slutprodukt og til vores hovedknap (initial knap for en kombination af spil) har også brugt de originale to knapper (se foto). De LED'er vil blive behandlet (disse var kun en indikation, så vi kan bruge alle de rigtige oplysninger til at fungere.

Trin 6: Arbejdende Originele -knapper + Dremelen

På videoen kan du se, hvordan de to originale knapper fungerer som en slags skabelon, vi kan bruge til at skabe en effekt, der kombineres med knapper.

Om vores egne knapper kan vi oprette de originale knapper, hvor vi har de originale knapper, som vi kan se på billedet.

Trin 7: Bedrading Solderen + Knapper Vastlijmen

Fordi vi ikke længere kan bruge et brødbræt, skal vi downloade de forskellige komponenter til at forbinde hinanden. Efter at dette kan ske, kan vi vise knapper, som du kan se på billederne. Eens dit events kan vi gennemgå de følgende trin.

Trin 8: Plader fremstillet i De Behuizing

Fordi dette Guitar Hero-model redelike krap var om mig at arbejde, har vi ekstra sted skal lave d.m.v. dremelen. Da vi har fjernet en bagkant af gitaren, er hele fjernelsen fjernet, så der er mere sted, hvor staten kan indlæses i gitaren. Fordi der er en overordnet størrelse inden for de indvendige obstakels, kan vi også fjerne, at vi har fjernet den optimale plads til den anvendte plads. Op de vierde og femde foto er at se, at vi i den bagkant af gitaar en dørgang har kontrolleret, at de kan trykke på knapperne, fordi gitaren ellers ikke er mere at sluiten var. En af de sidste billeder kan se, at vi får den direkte kontakt med ordene til en gat i en kant af den gitaar, der behandler forlader.

Trin 9: Bedrading Aansluiten Op Protobord

Om alle komponenter med hinanden kan vi bruge en protobord. Dette er en bordje, der på egen hånd fungerer på samme måde som et brødbord, men da betrouwbaarder og effektivitet. Vi har debedraderet til bordgrænsefladen, som du kan se på tredje foto. Dette bord er det centrale punkt, hvor vores forbindelser kan sammenlægges og sammenkendes (se foto 2).

Trin 10: Verstevigen

Som prikken over i'et er det meget vigtigt, at du kan dele den ekstra stabilitet. På dette foto kan vi se, hvordan vi har delt, at vi har haft d.m.v. dremelen achteraan de knapper forstevigen med dele karton.

Trin 11: Code Voor Het Communiceren Met Reaper

Denne kode er opgivet i to dele, den første del er i det arduino IDE (interaktivt udviklingsmiljø) skrevet. Koden bliver uploadet til selvstændig og skal bruges til at vente på alle sensorer og midi -controllere, der skal bruges til at behandle.

Behandlingen er den anden del. Denne kode skal bruges til alt, hvad arduino dørstationer modtager, og som kan bruges til Reaper.

Arduino

/* Denne kode er en grundlæggende skitse til kommunikation med Processing through Serial.

Det er en blueprint, hvor du kan sætte din egen kode

specificeret til dine egne knapper, potentiometre eller sensorer.

Den har et håndtryk for at sikre, at vi har kontakt

og det format, som vi kommunikerer i, afgøres

Det er vigtigt at konstruere budskabet på samme måde, så Processing ved, hvordan man dekonstruerer det og sender korrekte OSC-meddelelser til vores DAW

lavet til werkcollege AV&IT

oktober 2017

*

/ baudrate

const lang baudRate = 115200;

// tid til at vente i ms mellem meningsmålinger til benene

const int loopPauseTime = 200; // milli sekunder

// start- og slutværdier for meddelelsen sendt på Serial

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

const char contactCharacter = '|';

// pin -id'er

// andre globale 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;

// analoge sensorer

const int potPin = A5; // pin for tremolo

// Vi har brug for denne funktion for at etablere kontakt med Processing sketch

// Hold det her ugyldigt etablereContact () {while (Serial.available () <= 0) {Serial.print (contactCharacter); // send en forkælelse og vent på et svar … forsinkelse (loopPauseTime); } Serial.read (); }

ugyldig opsætning () {

// indstil pinModes for alle benene for (int i = 0; i <antalKnoppen; i ++) {pinMode (knopPinnen , INPUT); } pinMode (mainButton, INPUT); // Ukommenter, hvis du bruger sensorer, der fungerer på 3V i stedet for 5V // du bliver også nødt til at koble 'ext' -stiften til 3,3V // analogReference (EXTERNAL);

// initialiser Serial comms

Serial.begin (baudRate); mens (! Seriel); // vent på håndtryk etablereContact (); }

void loop () {

// TRIN 1: LÆS KNAPPER // poll alle stifterne og kortlæg aflæsningen til det relevante område 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); // eksempler: // float v0 = map (bpm, 0, 1023, 60, 250); // hvis du vil bruge en normaliseret float (f.eks. for volumen) // float v1 = map (analogRead (pin2), fromMin, fromMax, 0, 100) / 100.0;

// TRIN 2: SKRIV MEDDELELSE

Serial.print (startString); // start en meddelelsessekvens for (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 slutningen af meddelelsen Serial.print (endString);

// vent lidt..

forsinkelse (loopPauseTime); }

Forarbejdning

Ansvarsfraskrivelse: Ikke alle koder til behandling af skitser kan bruges her, for at få den fulde kode til at se filen: ProcessingSoundControl_handout_v6_1.pde i bijlage

De følgende instruktioner skal tilpasses (er nødvendige):

// Baudrate skal være ens i den arduino -skitse

endelig int baudRate = 115200;

// Søg efter IP -adressen i reaper (se skærmbilleder i bijlage)

// Behandler sendt til dit andres en reaper lytt hier to //

// final String remoteIP = "192.168.1.43"; //f.eks. "127.0.0.1";

sidste streng remoteIP = "10.3.209.60";

// Noter sendPort, og udfyld dette i Reaper.

// Dette er porten Processing sender til og Reaper lytter til.

sidste int listenPort = 12000, sendPort = 12000;

// ListenPort her skal aktivt debugge.

// portNames er også her for at fejlsøge.

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

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

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

import behandling. serie.*;

import java.util.*;

import oscP5.*;

import netP5.*;

OscP5 oscP5;

NetAddress myRemoteLocation;

Seriel commsPort; // Seriel port

boolsk messageArrived = false;

Indgående streng = "", IncomingOSCMessage = "";

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

// For at sikre, at vi kun sender de parametre (værdier), der ændres

// disse globale variabler er delcared her, men bør // ikke initialiseres her! HashMap oldParams, newParams, toSendParams;

// Vi skal dele meddelelsen ved hvert komma

void processIncoming () {String resVec = incoming.split (","); // vi får navn+værdipar // så for hvert navn (+2) … prøv {for (int i = 0; i <resVec.length; i+= 2) {float value = Float.parseFloat (resVec [i+ 1]); // læg dem i det nye Hashtable newParams.put (resVec , værdi); }} // // hvis der opstår en fejl, lad os få den vist og afslutte. catch (Undtagelse ex) {println ("Undtagelsesmeddelelse:" + eks); printArray (resVec); Afslut(); }}

// For at filtrere vores meddelelser

/ * Vi sørger for, at der kun er en OSC-out-meddelelse, når * inputmeddelelsen (Serial) ændres * Det vil sige: hvis vi drejer/trykker på knappen, og den ændrer værdi. * Så vi filtrerer de indgående værdier, der rent faktisk ændrer sig * Bemærk: vi undgår ikke at springe værdier * som f.eks. Fra accelerometre eller distancesensorer * du skal selv udjævne dem i Arduino */ void filterParams () {toSendParams = new HashMap (); for (String key: newParams.keySet ()) {// hvis nøglen allerede er til stede, hvis (oldParams.containsKey (key)) {// key present and value not the same, then update if (! oldParams.get (key).equals (newParams.get (key))) {toSendParams.put (key, newParams.get (key)); }} else {// nøgle findes ikke i gamle params, så sig det! toSendParams.put (key, newParams.get (key)); } oldParams.put (nøgle, newParams.get (nøgle)); }}

ugyldig makeOSC () {

for (Strenøgle: toSendParams.keySet ()) {OscMessage myMessage = ny OscMessage ("/"+ nøgle); myMessage.add (toSendParams.get (nøgle)); / * send beskeden */ oscP5.send (myMessage, myRemoteLocation); }}

void translateMessage () {

processIncoming (); filterParams (); makeOSC (); } // Når vi vil udskrive til vinduet, annullere ShowIncoming () {// for at se indgående besked, som angivet i HashMap -teksten ("Indgående fra Arduino", 20, 20); int y = 20; for (Strenøgle: newParams.keySet ()) {y = y+20; tekst (nøgle, 20, y); tekst (newParams.get (nøgle), 300, y); }}

void showOsc () {

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

ugyldig opsætning () {

størrelse (1000, 800); // Scenestørrelsesfyld (255); baggrund (0); oldParams = ny HashMap (); newParams = ny HashMap (); // printArray (Serial.list ()); commsPort = ny Serial (dette, portnavn, baudRate);

/ * start oscP5, lyt til indgående beskeder */

oscP5 = ny OscP5 (dette, listenPort);

/* myRemoteLocation er en NetAddress. en NetAddress tager 2 parametre, * en ip -adresse og et portnummer.myRemoteLocation bruges som parameter i * oscP5.send (), når osc -pakker sendes til en anden computer, enhed, * applikation. brug se nedenfor. til testformål er lytteporten * og porten til den eksterne placeringsadresse den samme, derfor sender du * beskeder tilbage til denne skitse. */ myRemoteLocation = ny NetAddress (remoteIP, sendPort); }

ugyldig tegning () {

hvis (messageArrived) {baggrund (0); translateMessage (); ShowIncoming (); messageArrived = false; } showOsc (); }

void serialEvent (Serial commsPort) {

// læs en byte fra den serielle port: char inChar = commsPort.readChar (); switch (inChar) {case contactCharacter: commsPort.write (contactCharacter); // bede om mere println ("starter …"); pause; case startChar: incoming = ""; pause; case endChar: messageArrived = true; // println ("end of msg"); pause; standard: indgående += inChar; pause; }}

/* indgående osc -besked videresendes til oscEvent -metoden. */

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

IncomingOSCMessage += "\ n" +

String.format ("### modtog en osc -meddelelse:" + "addrpattern:" + theOscMessage.addrPattern () + ": %f", værdi); println (IncomingOSCMessage); }

Trin 12: Controller Uittesten

Nu er alt angesloten, alle koder er skrevet, og alt er gedubbelcheckt er den endelige tid, hvor controlleren ikke kan arbejde. Find en par sjove effekter på Reaper og nyd den voltooide Guitar Hero MIDI Controller!