Arduino projekt Guitar Hero: 12 korakov (s slikami)

2024 Avtor: John Day | [email protected]. Nazadnje spremenjeno: 2024-01-30 12:08

Wij zijn Maarten Vrebos, Justin Cavanas in Wannes Stroobandt in we studeren multimedia & communicatietechnologie. Če želite več projektov za avdiovizualna in IT načela, ki jih uporabljate za kitaro, se obrnite na MIDI-krmilnik. Het was onze bedoeling om de bestaande knoppen op de gitaar intern te vervangen. Onze krmilnik zal widegehouden 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 sche op oppipi 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 kleine gumbov
• 7 1kohmskih uporov
• 1 LED lučka 1
• blauwe LED
• 1 Arduino Uno R3
• 1 žarnica LED
• 2 ročni LED
• 1 schuifschakelaar
• 1 plošča
• 1 potenciometer
• 1 protobord
• 1 Guitar Hero gitaar
• Voldoende posteljnina
• Materiali om te solderen/dremelen/
• Schroevendraaier

Korak: Sestavite Verzamelen

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

6 gumbov

7 1kohm uporov

1 Rumena LED

1 modra LED

1 Arduino Uno R3

1 zelena LED

2 rdeča LED

1 Schuifschakelaar

1 Ogledna plošča

1 Potenciometer

2. korak: Prototip Bouwen

Om ons prototip te bouwen hebben we al onze komponentten gebruikt op een breadboard, deze breadboard dient dan als testobject zodat we niet meteen in de behuizing te werk moeten gaan. Od prototipa hebben we dan ook gedigitaliseerd prek tinkercad.com, op deze manier hadden we een duidelijk overzicht van ons prototype dat elk groepslid ook kon bewerken.

Na voljo je 5 kleine gumbov, ki jih je treba prilagoditi ali zamenjati s 5 gumbi, ki so v kombinaciji z eno in več mešanicami "snaren" moet, ki so vključene v učinek dodajanja učinka. De verschillende LED-lampjes dienen gewoon als visuele controle om er zeker van te zijn dat de interactie succesvol werkt.

3. korak: Prototip kode

Globale variabelen

In het eerste deel van de code initialiseer je globale variabelen voor de pins van arduino uno waar allebuttons mee verbonden zijn.

// zet pin številke waar mainButton (snaar) en andere gumbi aan verbonden zijn: const int mainButton = A1; // gitaar snaar const int lightSensor = A0; const int buttonPin1 = 2; // tipka za številko kombi1 const int buttonPin2 = 3; // nummer van pushbutton2const int buttonPin3 = 4; // nummer van pushbutton3const int buttonPin4 = 5; // številka van pushbutton4const int buttonPin5 = 6; // tipka za številko kombija5

To pomeni, da so twee nizi namenjeni namenu tipk in gumbov.

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; // številka LED pin 13

const int ledPin2 = 12; // število LED pin 12 const int ledPin3 = 11; // število LED pin 11 const int ledPin4 = 10; // število LED pin 10 const int ledPin5 = 9; // število LED pin 9 const int potPin = A5; // število LED zatiča A5

De laatste globale variabelen dienen als 'states' for senzorji (zijn de pushbuttons ingedrukt of niet? Potenciometer, lichtsensor).

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

Nastaviti

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

void setup () {// hitrost prenosa podatkov na sekundo (baud) za prenos seriele podatkovnih sporočil Serial.begin (9600); // Initialiseer de ledPin variablelen als output pinMode (ledPin1, OUTPUT); pinMode (ledPin2, OUTPUT); pinMode (ledPin3, OUTPUT); pinMode (ledPin4, OUTPUT); pinMode (ledPin5, OUTPUT); // inicializator vseh tipk als input: pinMode (mainButton, INPUT); pinMode (buttonPin1, INPUT); pinMode (buttonPin2, INPUT); pinMode (buttonPin3, INPUT); pinMode (buttonPin4, INPUT); pinMode (buttonPin5, INPUT); pinMode (potPin, INPUT); pinMode (svetlobni senzor, VHOD); }

Funkcija praznine

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 = digitalno branje (buttonPin1); buttonState2 = digitalno branje (buttonPin2); buttonState3 = digitalno branje (buttonPin3); buttonState4 = digitalno branje (buttonPin4); buttonState5 = digitalno branje (buttonPin5);

// vse tipke statusen v matriki een

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

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

potValue = analogRead (potPin); lightValue = analogRead (svetlobni senzor);

// razglasi een array mainStates en geef die de standaard waarden 0 in.

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

// zanka nad de array aantalKnoppen

for (int i = 0; i <aantalKnoppen; i ++) {pinMode (knopPinnen , INPUT); // začetnik vseh knopPinnen tudi vhod digitalRead (knopPinnen ); // lees de waarde van alle knoppinnen uit // indien de mainswitch (snaar) ingedrukt is, print all knopnamen, all buttontates if (mainButtonState == HIGH) {Serial.print (namenKnoppen ); Serial.print (","); Serial.println (buttonStates ); }}

4. korak: Prototip Uittesten

Nadat het prototype gebouwd is volgens ons model en code de geschreven is in Processing, is het tijd om het prototype uit te testen. Op de video is te zien dat alle 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 potenciometer in de gitaar en hoe de waardes worden uitgelezen in Processing.

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

Če je koda pravilna, je prototip izdelan, ko smo začeli s "ontmantelen" van onze Guitar Hero-gitaar. We hebben de gitaar opengemaakt met een schroevendraaier en bekeken welke originele componentsnten we eventueel nog zouden kunnen hergebruiken voor onze controller. Uiteindelijk hebben we onze lastne gumbe v de bestaande gumbih 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 pravilno werkten.

6. korak: Delovni gumbi 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 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.

7. korak: Solderen Bedrading + gumbi Vastlijmen

Omdat we niet meer met een motherboard werken moeten de draden gesoldeerd worden om zo de verschillende componentsnten met elkaar te verbinden. Nadat dit gebeurd is kunnen we de buttons widelijmen zoals te zien is op de foto's. Eens dit gebeurd is kunnen we doorgaan naar de volgende stap.

8. korak: Plošče, izdelane v De Behuizingu

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 preprekels 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 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.

Korak 9: Bedrading Aansluiten Op Protobord

Vse komponente, ki jih je 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 centralle punt van waaruit al onze verbindingen vertrekken en samenkomen (zie foto 2).

10. korak: Verstevigen

Zaključek je tudi ta, da smo ohranili stabilnost in izgubili večjo stabilnost. Op deze foto is te zien hoe we het deel dat we er hebben uitgehaald d.m.v. dremelen achteraan de button verstevigen met stukjes karton.

Korak: Code Voor Het Communiceren Met Reaper

Koda Deze je opgedeeld v twee delen, njegova eerte deel pa je v de arduino IDE (interaktivno razvojno okolje). 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.

Predelava je iz tweede gedeelte. Deze code dient om alles wat arduino doorstuurt te ontvangen en door te sturen naar Reaper.

Arduino

/* Ta koda je osnovna skica za komunikacijo z Processing through Serial.

To je načrt, v katerega lahko vnesete svojo kodo

določeno za vaše gumbe, potenciometre ali senzorje.

Rokovanje ima za zagotovitev stika

in format, v katerem komuniciramo, je določen

Pomembno je, da sporočilo sestavite na enak način, tako da Processing ve, kako ga razgraditi in poslati ustrezna sporočila OSC v naš DAW

narejeno za werkcollege AV&IT

oktobra 2017

*

/ hitrost prenosa

const long baudRate = 115200;

// čas čakanja v ms med anketami do nožic

const int loopPauseTime = 200; // mili sekund

// začetne in končne vrednosti za sporočilo, poslano na Serial

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

const char contactCharacter = '|';

// pin ID -ji

// druge globalne spremenljivke

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;

// analogni senzorji

const int potPin = A5; // pin voor tremolo

// To funkcijo potrebujemo za vzpostavitev stika s skico Processing

// Naj ostane tukaj void installContact () {while (Serial.available () <= 0) {Serial.print (contactCharacter); // pošljemo char in počakamo na odgovor… delay (loopPauseTime); } Serial.read (); }

void setup () {

// nastavimo pinModes za vse nožice za (int i = 0; i <aantalKnoppen; i ++) {pinMode (knopPinnen , INPUT); } pinMode (mainButton, INPUT); // razkomentirajte, če uporabljate senzorje, ki delujejo na 3V namesto na 5V // boste morali priključiti tudi 'ext' pin na 3.3V // analogReference (EXTERNAL);

// inicializiramo serijske komunikacije

Serial.begin (baudRate); while (! Serijski); // počakajte na rokovanje installContact (); }

void loop () {

// 1. KORAK: GUMBI ZA BRANJE // poiščite vse zatiče in preslikajte branje v ustrezen obseg 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); // primeri: // float v0 = map (bpm, 0, 1023, 60, 250); // če želite uporabiti normaliziran plovec (npr. za volumen) // float v1 = map (analogRead (pin2), fromMin, fromMax, 0, 100) / 100.0;

// 2. KORAK: NAPIŠITE SPOROČILO

Serial.print (startString); // zaženemo zaporedje sporočil za (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 (zemljevid (potValue, 0, 1023, 0, 100)); // napišemo konec sporočila Serial.print (endString);

// malo počakaj..

zakasnitev (loopPauseTime); }

Obravnavati

Zavrnitev odgovornosti: 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 skica

končni int baudRate = 115200;

// Zoek naar het IP address in Reaper (Zie screenshots in bijlage)

// Predelava štuur naar dit andres en reaper luistert hier naar //

// končni niz oddaljen IP = "192.168.1.43"; // npr. "127.0.0.1";

final String remoteIP = "10.3.209.60";

// Zapomnite si sendPort in ga vnesite v Reaper.

// To so vrata, ki jih Processing pošlje in Reaper posluša.

končni int listenPort = 12000, sendPort = 12000;

// Tu je poslušalnik za aktivno odpravljanje napak.

// tudi imena portov so za odpravljanje napak.

// končni nizName portName = "/dev/ttyACM0";

finalni niz portName = "COM5"; // "/dev/ttyUSB0";

/////////////////////// KONEC PARAMETROV UPORABNIKOV /////////////////////////// ////

uvozna obdelava.serial.*;

uvoz java.util.*;

uvoz oscP5.*;

uvoz netP5.*;

OscP5 oscP5;

NetAddress myRemoteLocation;

Serijski commsPort; // Serijska vrata

logično sporočiloArrived = false;

Niz dohodni = "", IncomingOSCMessage = "";

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

// Poskrbimo, da pošljemo samo tiste parametre (vrednosti), ki se spremenijo

// te globalne spremenljivke so tukaj ločene, vendar jih // ne smemo inicializirati! HashMap oldParams, newParams, toSendParams;

// Sporočilo moramo razdeliti na vsako vejico

void processIncoming () {String resVec = incoming.split (","); // dobimo pare+ime/ vrednost // torej za vsako ime (+2)… poskusimo {for (int i = 0; i <resVec.length; i+= 2) {float value = Float.parseFloat (resVec [i+ 1]); // jih postavimo v novo Hashtable newParams.put (resVec , vrednost); }} // če pride do napake, naj jo prikažemo in zapustimo. catch (Izjema ex) {println ("Sporočilo o izjemi:" + ex); printArray (resVec); exit (); }}

// Za filtriranje naših sporočil

/ * Poskrbimo, da obstaja samo sporočilo o izhodu OSC, ko se * vhodno sporočilo (serijsko) spremeni * To pomeni: če gumb obrnemo/pritisnemo in spremeni vrednost. * Zato filtriramo dohodne vrednosti, ki se dejansko spremenijo * opomba: ne bomo se izognili preskakovanju vrednosti *, ki prihajajo iz npr. Merilnikov pospeška ali senzorjev razdalje *, ki jih boste morali sami zgladiti v Arduinu */ void filterParams () {toSendParams = new HashMap (); for (String key: newParams.keySet ()) {// če je ključ že prisoten, če (oldParams.containsKey (key)) {// ključ je prisoten in vrednost ni enaka, nato posodobite if (! oldParams.get (key).equals (newParams.get (key))) {toSendParams.put (key, newParams.get (key)); }} else {// ključ ni prisoten v starih paramih, zato povejte! toSendParams.put (ključ, newParams.get (ključ)); } oldParams.put (ključ, newParams.get (ključ)); }}

void makeOSC () {

for (Ključni niz: toSendParams.keySet ()) {OscMessage myMessage = nov OscMessage ("/"+ ključ); myMessage.add (toSendParams.get (ključ)); / * pošlji sporočilo */ oscP5.send (myMessage, myRemoteLocation); }}

void translateMessage () {

processIncoming (); filterParams (); makeOSC (); } // Ko želimo tiskati v okno void ShowIncoming () {// za prikaz dohodnega sporočila, kot je nastavljeno v besedilu HashMap ("Incoming from Arduino", 20, 20); int y = 20; for (Niz ključa: newParams.keySet ()) {y = y+20; besedilo (ključ, 20, y); besedilo (newParams.get (key), 300, y); }}

void showOsc () {

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

void setup () {

velikost (1000, 800); // Zapolnitev velikosti stopnje (255); ozadje (0); oldParams = nov HashMap (); newParams = nov HashMap (); // printArray (Serial.list ()); commsPort = new Serial (this, portName, baudRate);

/ * zaženite oscP5, poslušajte dohodna sporočila */

oscP5 = nov OscP5 (to, poslušajPort);

/* myRemoteLocation je NetAddress. NetAddress ima 2 parametra, * naslov IP in številka vrat.myRemoteLocation se uporablja kot parameter v * oscP5.send () pri pošiljanju paketov osc v drug računalnik, napravo, * aplikacijo. uporabo glejte spodaj. za namene testiranja so vrata za poslušanje * in vrata naslova oddaljene lokacije enaka, zato boste sporočila * poslali nazaj na to skico. */ myRemoteLocation = nov NetAddress (remoteIP, sendPort); }

void draw () {

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

void serialEvent (Serial commsPort) {

// preberemo bajt iz zaporednih vrat: char inChar = commsPort.readChar (); switch (inChar) {case contactCharacter: commsPort.write (contactCharacter); // zahtevaj več println ("zagon …"); prekiniti; primer startChar: incoming = ""; prekiniti; primer endChar: messageArrived = true; // println ("konec sporočila"); prekiniti; privzeto: dohodni += inChar; prekiniti; }}

/* dohodno sporočilo osc se posreduje metodi oscEvent. */

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

Dohodno OSCMessage += "\ n" +

String.format ("### je prejel sporočilo osc:" + "addrpattern:" + theOscMessage.addrPattern () + ": %f", vrednost); println (IncomingOSCMessage); }

Korak: Uittesten krmilnika

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. Zoek een paar leuke efecten op Reaper and geniet van de voltooide Guitar Hero MIDI Controller!