Guitar Hero Arduino -projek: 12 stappe (met foto's)

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:27

Ons is Maarten Vrebos, Justin Cavanas en Wannes Stroobandt en ons bied multimedia en kommunikasie tegnologie aan. Vir 'n groepsprojek vir die vak Audiovisuele en IT-beginsels het ons 'n Guitar Hero-gitaar gebruik en gebruik om ons MIDI-kontroleerder te gebruik. Dit was ons bedoeling om die bestaande knop op die gitaar intern te vervang. Ons kontroleerder word as 'n normale gitaar groot en gehou. Aangesien ons iets het, het ons nie veel ekstra materiaal nodig nie.

In die prentjie kan u ons algemene sketse op papier sien hoe die eindproduk ook 'n foto van die gitaar moet sien as die bewerking sal gebruik word.

Ons het vir hierdie projek gebaseer op die volgende bronne:

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 klein drukknoppies
• 7 1 kohm weerstande
• 1 gele LED 1
• blou LED
• 1 Arduino Uno R3
• 1 groene LED
• 2 LED's gery
• 1 schuifschakelaar
• 1 broodbord
• 1 potensiometer
• 1 protobord
• 1 kitaarheld -gitaar
• Voldoende bedrading
• Materiaal om solderen/dremelen/
• Schroevendraaier

Stap 1: Componenten Verzamelen

Vir ons prototipe (op broodbord) het ons die volgende komponente gebruik:

6 drukknoppies

7 1 khm weerstande

1 geel LED

1 Blou LED

1 Arduino Uno R3

1 groen LED

2 Rooi LED

1 Schuifschakelaar

1 Broodbord

1 Potensiometer

Stap 2: Prototipe Bouwen

Om ons prototipe te bou, het ons al ons komponente op 'n broodbord gebruik, en hierdie broodbord kan ook as 'n testobjek gebruik word, sodat ons nie in staat is om te werk nie. Hierdie prototipe het ons ook via tinkercad.com gedigitaliseer, en op hierdie manier het ons 'n duidelike oorsig van ons prototipe gehad wat elke groep ook kon bewerk.

Daar word 5 klein drukknoppies gebruik wat as 5 snare en 'n groot drukknop in kombinasie met een of meer 'snare' gebruik moet word om 'n ouditeffek te kry. Die verskillende LED-lampe dien gewoonlik net as 'n visuele beheer om die sukses van die interaksie te verseker.

Stap 3: Kode prototipe

Globale variasie

In die eerste deel van die kode kan u die globale veranderings vir die pinne van die drukknoppies met alle knoppies verbind.

// zet pin numbers waar mainButton (snaar) en ander knoppies aan verbonden is: const int mainButton = A1; // gitaar snaar const int lightSensor = A0; const int buttonPin1 = 2; // nommer van drukknop1 const int buttonPin2 = 3; // nommer van pushbutton2const int buttonPin3 = 4; // nummer van drukknop3const int buttonPin4 = 5; // nummer van drukknop4const int buttonPin5 = 6; // nommer van drukknop5

Hier word twee arrays aangepas vir die name van die drukknoppies en die 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};

Daar is ook nog 'n variëteit vir LED -lampe.

const int ledPin1 = 13; // die nommer van die LED -pen 13

const int ledPin2 = 12; // die aantal LED -pen 12 const int ledPin3 = 11; // die aantal LED -pen 11 const int ledPin4 = 10; // die aantal LED -pen 10 const int ledPin5 = 9; // die aantal LED -pen 9 const int potPin = A5; // die aantal LED -pen A5

Die laaste globale variabelen dien as 'state' voor de sensors (zijn de drukknoppen ingedrukt van 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;

Stel op

Nou volg die leegte opstelfunksie. Dit is van die tipe leegte (gee geen waarde terug nie) en die instruksies word slegs een keer uitgevoer.

By elke funksie is kommentaar geskrywe wat daar konkreet gedoen word. Ekstra uitleg oor wat 'n spesifieke funksie is om konkrete dinge te vind in die arduino -verwysing

void setup () {// data rate per seconde (baud) for seriele data transmissie Serial.begin (9600); // Initialiseer die ledPin -variabelen as output pinMode (ledPin1, OUTPUT); pinMode (ledPin2, OUTPUT); pinMode (ledPin3, OUTPUT); pinMode (ledPin4, OUTPUT); pinMode (ledPin5, OUTPUT); // begin alle drukknoppies as invoer: pinMode (hoofknoppie, INVOER); pinMode (buttonPin1, INPUT); pinMode (buttonPin2, INPUT); pinMode (buttonPin3, INPUT); pinMode (buttonPin4, INPUT); pinMode (buttonPin5, INPUT); pinMode (potPin, INPUT); pinMode (lightSensor, INPUT); }

Ongeldige funksie

Na die opstelling () funksie volg die loop () funksie, die instruksies wat hierin staan, kan uitgevoer word.

void loop () {// lees die staat van die drukknoppies uit (ingedrukt of nie) mainButtonState = digitalRead (mainButton); buttonState1 = digitalRead (buttonPin1); buttonState2 = digitalRead (buttonPin2); buttonState3 = digitalRead (buttonPin3); buttonState4 = digitalRead (buttonPin4); buttonState5 = digitalRead (buttonPin5);

// alle drukknoppies in een skikking

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

// leest die waarde uit die potensiometer en die lichtsensor

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

// verklaar 'n reeks hoofstate en die standaardwaarde word 0 in.

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

// loop oor die skikking aantalKnoppen

for (int i = 0; i <aantalKnoppen; i ++) {pinMode (knopPinnen , INPUT); // initialize alle knopPinnen as input digitalRead (knopPinnen ); // lees die waarde van alle knoppinne uit // indien die mainswitch (snaar) ingedrukt is, print alle knopnamen, alle buttonstates if (mainButtonState == HIGH) {Serial.print (namenKnoppen ); Serial.print (","); Serial.println (buttonStates ); }}

Stap 4: Prototipe Uittesten

Nadat die prototipe gebou is volgens ons model en die kode wat in die verwerking is, is dit tyd om die prototipe uit te toets. Op die video kan u sien dat alle reaksies op verskillende horlosies en ook kombinasies van knoppies moontlik is.

In die tweede video kan ons sien hoe ons tremolo aan die hand van 'n potensiometer kan werk en hoe dit in verwerking uitgegee kan word.

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

As die kode korrek werk op die prototipe, begin ons met die "ontmantel" van ons kitaar-held-kitaar. Ons het 'n opengemaakt met 'n skroevendraaier en kan bekyk watter oorspronklike komponente ons moontlik nog kan gebruik vir ons beheerder. Ons het eintlik ons eie drukknoppies in die bestaande knoppies gekregen (sien volgende stap). Ons het die tremolo ook gebruik vir ons eindproduk en vir ons hoofknoppie (oorspronklike knoppie as 'n kombinasie van speel) en ons het ook die oorspronklike twee knoppies gebruik (sien vierde foto). Die LED's sal verdwyn (hierdie was slegs 'n aanduiding, sodat ons dit alles kan regstel.

Stap 6: Werkende Originele -knoppies + Dremelen

Op die byhorende video kan die manier waarop die twee oorspronklike knoppies gesien word, werk as 'n soort skakels wat ons gebruik om 'n effek te skep om 'n kombinasie van knoppies te maak.

Om ons eie knoppies te verwerk in die oorspronklike knoppe, het ons die binnekant van die oorspronklike groot dele soos ons sien op die foto.

Stap 7: Bedrading Solderen + knoppies Vastlijmen

Omdat ons nie meer met 'n broodbord kan werk nie, moet ons die gesamentlike geskenke vir verskillende komponente met mekaar verbind. Nadat dit gebeur het, kan ons groot knoppies soos foto's op die foto's sien. Dit kan gebeur dat ons deur die volgende stap kan gaan.

Stap 8: Plaats gemaak in De Behuizing

Omdat hierdie Guitar Hero-model 'n redelike krap was om te werk, het ons 'n ekstra plek nodig om d.m.v. dremelen. Ons het die agterkant van die gitaar 'n hele strook verwyder sodat ons meer 'n plek vir die bedrading in die gitaar kan hê. Omdat daar in die binnekant van die obstakels ook 'n groot aantal beveiligingsinstruksies vir ons beskikbaar is, kan ons ook die optimale ruimte vir die gebruik van die ruimte verwyder. Op die vierde en vyfde foto kan ons sien dat ons in die agterkant van die gitaar 'n deurgang kan kry om die knoppies na die knoppies te gaan omdat die gitaar anders nie meer kan sluit nie. En op die laaste foto sal ons sien dat ons die direkte verbond met die Arduino deur 'n gat in die onderkant van die gitaar van die behuizing van verlate kan sien.

Stap 9: Bedrading Aansluiten Op Protobord

Om alle komponente met mekaar te verbind, het ons 'n protobord gebruik. Dit is 'n bordjie wat op 'n dieselfde manier werk as 'n broodbord, maar ook 'n betrouwbare en effektiewe manier. Ons het 'n bedrading op die bord geslag, soos ons op die derde foto kan sien. Dit is 'n sentrale punt van waar ons al ons verbindings en rekords kan sien (sien foto 2).

Stap 10: Verstevigen

As afwerking is die verstek om die losse dele te versterk vir ekstra stabiliteit. Op hierdie foto kan ons sien hoe ons deelneem dat ons d.m.v. dremelen achteraan de buttons verstevigen with kartjes karton.

Stap 11: Code For Het Communiceren Met Reaper

Hierdie kode word opgedeel in twee dele, die eerste deel is in die IDE (interaktiewe ontwikkelingsomgewing) geskrywe. Die kode word geüpload na ons eie en moet alle wagens van die sensore van die midi -kontroleerder uithaal en u kan dit verwerk.

Verwerking is die tweede gedeelte. Hierdie kode moet alles wat 'n deurstuur vir u ontvang, ontvang en deur na Reaper gestuur word.

Arduino

/* Hierdie kode is 'n basiese skets om te kommunikeer met Processing through Serial.

Dit is 'n bloudruk waarin u u eie kode kan plaas

gespesifiseer vir u eie knoppies, potensiometers of sensors.

Dit het 'n handdruk om seker te maak dat ons kontak het

en die formaat waarin ons kommunikeer word besluit

Dit is belangrik om die boodskap op dieselfde manier te konstrueer, sodat Processing weet hoe om dit te dekonstrueer en die korrekte OSC-boodskappe na ons DAW te stuur

gemaak vir werkcollege AV&IT

okt 2017

*

/ baud koers

const long baudRate = 115200;

// tyd om in ms te wag tussen peilings tot by die penne

const int loopPauseTime = 200; // milli sekondes

// begin- en eindwaardes vir die boodskap wat op Serial gestuur is

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

const char contactCharacter = '|';

// pin ID's

// ander globale veranderlikes

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;

// analoge sensors

const int potPin = A5; // pin voor tremolo

// Ons benodig hierdie funksie om kontak te maak met die verwerkingskets

// Hou dit hier ongeldig establishmentContact () {while (Serial.available () <= 0) {Serial.print (contactCharacter); // stuur 'n char en wag vir 'n antwoord … vertraging (loopPauseTime); } Serial.read (); }

ongeldige opstelling () {

// stel die pinModes in vir al die penne vir (int i = 0; i <aantalKnoppen; i ++) {pinMode (knopPinnen , INPUT); } pinMode (hoofknoppie, INVOER); // onkommentaar as jy sensors gebruik wat op 3V werk in plaas van 5V // jy moet ook die 'ext' pen na 3,3V bedraai // analogReference (EXTERNAL);

// inisialiseer Serial comms

Serial.begin (baudRate); terwyl (! Serial); // wag vir 'n handdruk, createContact (); }

leemte -lus () {

// STAP 1: LEES KNOPPE // poll al die penne en karteer die lesing na die toepaslike reeks 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); // voorbeelde: // float v0 = kaart (bpm, 0, 1023, 60, 250); // as u 'n genormaliseerde vlotter wil gebruik (bv. vir volume) // float v1 = map (analogRead (pin2), fromMin, fromMax, 0, 100) / 100.0;

// STAP 2: SKRYF BOODSKAP

Serial.print (startString); // begin 'n boodskapreeks vir (int i = 0; i <aantalKnoppen; i ++) {if (mainButtonState == HOOG) {Serial.print (namenKnoppen ); Serial.print (","); Serial.print (buttonStates ); if (i <aantalKnoppen - 1) {Serial.print (","); }} anders {buttonStates = 0; Serial.print (naamKnoppen ); Serial.print (","); Serial.print (buttonStates ); if (i <aantalKnoppen - 1) {Serial.print (","); }}} Serial.print (","); Serial.print ("tremolo"); Serial.print (","); Serial.print (kaart (potValue, 0, 1023, 0, 100)); // skryf die einde van die boodskap Serial.print (endString);

// wag 'n rukkie..

vertraging (loopPauseTime); }

Verwerking

Disclaimer: Die kode van die verwerkingskets kan hier in die volledige kode gesien word, vir die volledige kode: die ProcessingSoundControl_handout_v6_1.pde in bijlage

Die volgende instruksies moet aangepas word (indien nodig):

// Baudrate moet dieselfde wees as in die arduino -skets

finale int baudRate = 115200;

// Soek na die IP -adres in reaper (sien skermkiekies in bylage)

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

// finale string remoteIP = "192.168.1.43"; // bv. "127.0.0.1";

finale string remoteIP = "10.3.209.60";

// Let op die sendPort en vul dit in Reaper in.

// Dit is die poort waarna Verwerking stuur en waarna Reaper luister.

finale int listenPort = 12000, sendPort = 12000;

// Die luisterpoort hier is om aktief te ontfout.

// die portname is ook hier om te ontfout.

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

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

/////////////////////// EINDE VAN GEBRUIKERSPARAMETERS //////////////////////// ////

invoerverwerking.reeks.*;

invoer java.util.*;

invoer oscP5.*;

voer netP5 in.*;

OscP5 oscP5;

NetAddress myRemoteLocation;

Serial commsPort; // Die reekspoort

boolean messageArrived = false;

Inkomende string = "", IncomingOSCMessage = "";

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

// Om seker te maak dat ons slegs die parameters (waardes) stuur wat verander

// hierdie globale veranderlikes word hier versorg, maar moet // nie hier geïnisialiseer word nie! HashMap oldParams, newParams, toSendParams;

// Ons moet die boodskap by elke komma verdeel

void processIncoming () {String resVec = incoming.split (","); // ons kry naam+waarde pare // so vir elke naam (+2) … probeer {for (int i = 0; i <resVec.length; i+= 2) {float value = Float.parseFloat (resVec [i+ 1]); // plaas dit in die nuwe Hashtable newParams.put (resVec , waarde); }}} // as 'n fout voorkom, laat ons dit vertoon en verlaat. catch (Exception ex) {println ("Exception Message:" + ex); printArray (resVec); uitgang (); }}

// Om ons boodskappe te filter

/ * Ons sorg dat daar slegs 'n OSC-out-boodskap is wanneer * die invoerboodskap (Serial) verander * Dit wil sê: as ons die knoppie draai/druk en dit waarde verander. * Dus filter ons die inkomende waardes wat eintlik verander * let op: ons sal nie springwaardes vermy nie * soos afkomstig van versnellingsmeters of afstandsensors * u moet dit self glad maak in Arduino */ void filterParams () {toSendParams = new HashMap (); vir (String key: newParams.keySet ()) {// as die sleutel reeds teenwoordig is as (oldParams.containsKey (key)) {// key present en waarde nie dieselfde is nie, werk dan op as (! oldParams.get (key).gelyk (newParams.get (sleutel))) {toSendParams.put (sleutel, newParams.get (sleutel)); }} anders {// sleutel is nie in ou params beskikbaar nie, so stel dit! toSendParams.put (sleutel, newParams.get (sleutel)); } oldParams.put (sleutel, newParams.get (sleutel)); }}

nietige makeOSC () {

vir (String -sleutel: toSendParams.keySet ()) {OscMessage myMessage = nuwe OscMessage ("/"+ sleutel); myMessage.add (toSendParams.get (sleutel)); / * stuur die boodskap */ oscP5.send (myMessage, myRemoteLocation); }}

void translateMessage () {

processIncoming (); filterParams (); makeOSC (); } // Wanneer ons na die venster wil afdruk, leegmaak ShowIncoming () {// om inkomende boodskap te sien, soos gestel in die HashMap -teks ("Inkomend uit Arduino", 20, 20); int y = 20; vir (String sleutel: newParams.keySet ()) {y = y+20; teks (sleutel, 20, y); teks (newParams.get (sleutel), 300, y); }}

leegte showOsc () {

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

ongeldige opstelling () {

grootte (1000, 800); // Stadiumgrootte vul (255); agtergrond (0); oldParams = nuwe HashMap (); newParams = nuwe HashMap (); // printArray (Serial.list ()); commsPort = nuwe reeks (hierdie, poortnaam, baudRate);

/ * begin oscP5, luister na inkomende boodskappe */

oscP5 = nuwe OscP5 (hierdie, luisterPort);

/* myRemoteLocation is 'n NetAddress. 'n NetAddress neem 2 parameters, * 'n ip -adres en 'n poortnommer.myRemoteLocation word gebruik as parameter in * oscP5.send () wanneer osc -pakkies na 'n ander rekenaar, toestel, * toepassing gestuur word. gebruik sien hieronder. Vir toetsdoeleindes is die luisterpoort * en die poort van die afgeleë adres dieselfde, daarom stuur u * boodskappe terug na hierdie skets. */ myRemoteLocation = nuwe NetAddress (remoteIP, sendPort); }

nietige trekking () {

if (messageArrived) {agtergrond (0); translateMessage (); ShowIncoming (); messageArrived = vals; } showOsc (); }

ongeldig serialEvent (Serial commsPort) {

// lees 'n greep uit die seriële poort: char inChar = commsPort.readChar (); switch (inChar) {case contactCharacter: commsPort.write (contactCharacter); // vra vir meer druk ("begin …"); breek; case startChar: inkomend = ""; breek; case endChar: messageArrived = true; // println ("einde van boodskap"); breek; verstek: inkomende += inChar; breek; }}

/* inkomende osc -boodskap word na die oscEvent -metode gestuur. */

void oscEvent (OscMessage theOscMessage) {float value = theOscMessage.get (0).floatValue (); // kry die 1ste osc -argument

IncomingOSCMessage += "\ n" +

String.format ("### het 'n osc -boodskap ontvang:" + "addrpattern:" + theOscMessage.addrPattern () + ": %f", waarde); println (IncomingOSCMessage); }

Stap 12: Beheerder Uittesten

Alles is aangesloten, alle kode is geskrywe en alles is gedubbelcheckt is die eindelike tyd om die beheerder te laat werk. Soek 'n paar lekker effekte op Reaper en geniet van die voltooide Guitar Hero MIDI Controller!