Proiectul Guitar Hero Arduino: 12 pași (cu imagini)

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:46

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.

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 project

• 6 butoane kleine
• 7 rezistențe de 1 kohm
• 1 LED gele 1
• blauwe LED
• 1 Arduino Uno R3
• 1 LED groene
• 2 LED-uri rode
• 1 schuifschakelaar
• 1 panou
• 1 potențiometru
• 1 protobord
• 1 Guitar Hero gitaar
• Voldoende lenjerie de pat
• Materiaal om te solderen / dremelen /
• Schroevendraaier

Pasul 1: Componenten Verzamelen

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

6 Butoane

7 rezistențe de 1 kohm

1 LED galben

1 LED albastru

1 Arduino Uno R3

1 LED verde

2 LED roșu

1 Schuifschakelaar

1 Pană de pâine

1 Potențiometru

Pasul 2: Prototip Bouwen

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 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 vizuele control om er zeker van te zijn dat de interactionie succesvol werkt.

Pasul 3: Cod prototip

Globale variabelen

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; butonul const intPin1 = 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; // numărul pinului LED 13

const int ledPin2 = 12; // numărul de pin LED 12 const int ledPin3 = 11; // numărul LED pin 11 const int ledPin4 = 10; // numărul de pin LED 10 const int ledPin5 = 9; // numărul de pin LED 9 const int potPin = A5; // numărul pinului LED A5

De laatste globale variabilen 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;

Înființat

Nu 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 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 () {// data rate per seconde (baud) voor seriele data transmissie Serial.begin (9600); // Initialiseer de ledPin variabilen als output pinMode (ledPin1, OUTPUT); pinMode (ledPin2, OUTPUT); pinMode (ledPin3, OUTPUT); pinMode (ledPin4, OUTPUT); pinMode (ledPin5, OUTPUT); // inițializează toate butoanele de intrare: pinMode (mainButton, INPUT); pinMode (buttonPin1, INPUT); pinMode (buttonPin2, INPUT); pinMode (buttonPin3, INPUT); pinMode (buttonPin4, INPUT); pinMode (buttonPin5, INPUT); pinMode (potPin, INPUT); pinMode (lightSensor, INPUT); }

Void functie

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

// all pushbutton statusen in een array

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

// loop over de array 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 alle knopnamen, all buttonstates if (mainButtonState == HIGH) {Serial.print (namenKnoppen ); Serial.print (","); Serial.println (buttonStates ); }}

Pasul 4: Prototip 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 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.

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

Als code code 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 originele twee buttons gebruikt (zie vierde foto). De LEDjes zullen verdwijnen (deze waren enkel ter indicatie zodat we zagen dat alle knoppen correct werkten.

Pasul 6: Werking Butoane 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 combinație van knoppen.

Om onze eigen buttons te verwerken in de origine knoppen hebben we de binnenkant van de originelen er grotendeels uitgehaald zoals te zien is op de foto.

Pasul 7: Soluție pentru dormit + Butoane 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.

Pasul 8: Plaats Maken în 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.

Pasul 9: Bedrading Aansluiten Op Protobord

Om all 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).

Pasul 10: Verstevigen

Atingerea finală este versatilă pentru a pierde delena și pentru a stabiliza mai mult. 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.

Pasul 11: Code Voor Het Communiceren Met Reaper

Codul Deze este disponibil în twee delen, dar acesta este în arduino IDE (mediu de dezvoltare interactivă) 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.

Prelucrarea este het tweede gedeelte. Deze code dient om alles wat arduino doorstuurt te ontvangen en door te sturen naar Reaper.

Arduino

/ * Acest cod este o schiță de bază pentru a comunica cu Procesarea prin Serial.

Este un plan în care vă puteți pune propriul cod

specificat pentru propriile butoane, potențiometre sau senzori.

Are o strângere de mână pentru a ne asigura că avem contact

iar formatul în care comunicăm este decis

Este important să construim mesajul în același mod, astfel încât Processing să știe cum să-l deconstruiască și să trimită mesaje OSC corecte către DAW-ul nostru

creat pentru werkcollege AV&IT

octombrie 2017

*

/ rata baud

const long baudRate = 115200;

// timpul de așteptare în ms între sondaje la pini

const int loopPauseTime = 200; // milli secunde

// valori de început și de sfârșit pentru mesajul trimis pe Serial

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

const char contactCharacter = '|';

// cod de identificare

// alte variabile globale

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;

// senzori analogici

const int potPin = A5; // pin voor tremolo

// Avem nevoie de această funcție pentru a stabili contactul cu schița de procesare

// Păstrați-l aici nul EstablContact () {while (Serial.available () <= 0) {Serial.print (contactCharacter); // trimiteți un caracter și așteptați un răspuns … întârziere (loopPauseTime); } Serial.read (); }

configurare nulă () {

// setați pinModes pentru toți pinii pentru (int i = 0; i <aantalKnoppen; i ++) {pinMode (knopPinnen , INPUT); } pinMode (mainButton, INPUT); // descomentați dacă utilizați senzori care funcționează pe 3V în loc de 5V // va trebui să conectați și pinul „ext” la 3,3V // analogReference (EXTERNAL);

// inițializează comunicări seriale

Serial.begin (baudRate); while (! Serial); // așteptați strângerea de mână, stabilițiContact (); }

bucla nulă () {

// PASUL 1: CITIȚI BUTOANE // interogați toți pinii și mapați citirea la intervalul corespunzător 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); // exemple: // float v0 = hartă (bpm, 0, 1023, 60, 250); // dacă doriți să utilizați un float normalizat (de exemplu, pentru volum) // float v1 = map (analogRead (pin2), fromMin, fromMax, 0, 100) / 100.0;

// PASUL 2: SCRIERE MESAJ

Serial.print (startString); // începe o secvență de mesaje pentru (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 (hartă (potValue, 0, 1023, 0, 100)); // scrie sfârșitul mesajului Serial.print (endString);

// așteptați un timp..

întârziere (loopPauseTime); }

Prelucrare

Disclaimer: Niet all code for processing sketch staat hier in geschreven, voor de volledige code zie het bestand: ProcessingSoundControl_handout_v6_1.pde in bijlage

De volgende instruiește moeten aangepast worden (indien nodig):

// Baudrate moet hetzelfde zijn zoals in de arduino sketch

final int baudRate = 115200;

// Zoek naar het IP adress in reaper (zie screenshots in bijlage)

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

// final String remoteIP = "192.168.1.43"; //de exemplu. "127.0.0.1";

final String remoteIP = "10.3.209.60";

// Ia act de sendPort și completează acest lucru în Reaper.

// Acesta este portul pe care procesarea îl trimite și Reaper îl ascultă.

final int listenPort = 12000, sendPort = 12000;

// ListenPort aici este pentru a depana în mod activ.

// portNames sunt aici pentru a depana, de asemenea.

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

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

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

procesare import.serial. *;

import java.util. *;

import oscP5. *;

import netP5. *;

OscP5 oscP5;

NetAddress myRemoteLocation;

Serial commsPort; // Portul serial

mesaj boolean Sosit = fals;

Șir de intrare = "", IncomingOSCMessage = "";

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

// Pentru a ne asigura că trimitem numai parametrii (valorile) care se modifică

// aceste variabile globale sunt delcarate aici, dar nu ar trebui // inițializate aici! HashMap oldParams, newParams, toSendParams;

// Trebuie să împărțim mesajul la fiecare virgulă

void processIncoming () {String resVec = incoming.split (","); // obținem perechi nume + valoare // deci pentru fiecare nume (+2) … încercați {pentru (int i = 0; i <resVec.length; i + = 2) {float value = Float.parseFloat (resVec [i + 1]); // puneți-le în noul Hashtable newParams.put (resVec , valoare); }} // dacă apare o eroare, să o prindem afișată și ieșită. catch (Exception ex) {println ("Exception Message:" + ex); printArray (resVec); Ieșire(); }}

// Pentru a ne filtra mesajele

/ * Ne asigurăm că există doar un mesaj OSC-out când * mesajul de intrare (Serial) se schimbă * Adică: dacă rotim / apăsăm butonul și schimbă valoarea. * Deci, filtrăm valorile de intrare care se modifică efectiv * notă: nu vom evita sărirea valorilor *, deoarece provin de la accelerometre sau senzori de distanță * va trebui să le netezi singur în Arduino * / void filterParams () {toSendParams = new HashMap (); for (Cheie șir: newParams.keySet ()) {// dacă cheia este deja prezentă dacă (vechiParams.containsKey (cheie)) {// cheie prezentă și valoarea nu este aceeași, atunci actualizați dacă (! oldParams.get (cheie).equals (newParams.get (key))) {toSendParams.put (key, newParams.get (key)); }} else {// cheia nu este prezentă în parametrii vechi, așa că puneți-o! toSendParams.put (cheie, newParams.get (cheie)); } oldParams.put (cheie, newParams.get (cheie)); }}

void makeOSC () {

for (Cheie șir: toSendParams.keySet ()) {OscMessage myMessage = new OscMessage ("/" + cheie); myMessage.add (toSendParams.get (cheie)); / * trimite mesajul * / oscP5.send (myMessage, myRemoteLocation); }}

void translateMessage () {

processIncoming (); filterParams (); makeOSC (); } // Când vrem să tipărim în fereastră nul ShowIncoming () {// pentru a vedea mesajul primit, așa cum este setat în textul HashMap („Incoming from Arduino”, 20, 20); int y = 20; pentru (Cheie șir: newParams.keySet ()) {y = y + 20; text (cheie, 20, y); text (newParams.get (cheie), 300, y); }}

void showOsc () {

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

configurare nulă () {

dimensiune (1000, 800); // Umplerea dimensiunii etapei (255); fundal (0); oldParams = new HashMap (); newParams = new HashMap (); // printArray (Serial.list ()); commsPort = serial nou (this, portName, baudRate);

/ * pornește oscP5, ascultând mesajele primite * /

oscP5 = nou OscP5 (acesta, ascultăPort);

/ * myRemoteLocation este un NetAddress. un NetAddress ia 2 parametri, * o adresă IP și un număr de port.myRemoteLocation este utilizat ca parametru în * oscP5.send () la trimiterea pachetelor osc către alt computer, dispozitiv, * aplicație. utilizare vezi mai jos. în scopul testării, portul de ascultare * și portul adresei locației la distanță sunt aceleași, prin urmare, veți * trimite mesaje înapoi la această schiță. * / myRemoteLocation = new NetAddress (remoteIP, sendPort); }

draw nul () {

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

void serialEvent (Serial commsPort) {

// citiți un octet din portul serial: char inChar = commsPort.readChar (); switch (inChar) {case contactCharacter: commsPort.write (contactCharacter); // cere mai multe println („pornind …”); pauză; case startChar: incoming = ""; pauză; case endChar: messageArrived = true; // println ("sfârșitul mesajului"); pauză; implicit: incoming + = inChar; pauză; }}

/ * mesajele osc primite sunt redirecționate către metoda oscEvent. * /

void oscEvent (OscMessage theOscMessage) {float value = theOscMessage.get (0).floatValue (); // obține primul argument OSC

IncomingOSCMessage + = "\ n" +

String.format ("### a primit un mesaj osc:" + "addrpattern:" + theOscMessage.addrPattern () + ":% f", valoare); println (IncomingOSCMessage); }

Pasul 12: Uittesten de controler

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. Încercați să efectuați un efect pe Reaper în genet de voltooide Guitar Hero MIDI Controller!