Ģitāras varoņa Arduino projekts: 12 soļi (ar attēliem)

2024 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2024-01-30 10:57

Wij zijn Maarten Vrebos, Justin Cavanas un Wannes Stroobandt en we studeren multimedia & communicationatietechnologie. 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 normale gitaar. Aangezien we iets hebben gehackt hebben we er niet veel extra material 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 projekts

• 6 kleine spiedpogas
• 7 1kohm rezistori
• 1 dzelzs LED 1
• melns LED
• 1 Arduino Uno R3
• 1 gaismas diode
• 2 brauca ar gaismas diodēm
• 1 schuifschakelaar
• 1 maizes dēlis
• 1 potenciometrs
• 1 protobords
• 1 Guitar Hero ģitāra
• Voldoende gultasvieta
• Materiaal om te solderen/dremelen/
• Schroevendraaier

1. darbība: Componenten Verzamelen

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

6 Spiedpogas

7 1kohm rezistori

1 dzeltena gaismas diode

1 zila gaismas diode

1 Arduino Uno R3

1 zaļa gaismas diode

2 Sarkana gaismas diode

1 Schuifschakelaar

1 Maizes dēlis

1 potenciometrs

2. solis: Bouwen prototips

Om ons prototype te bouwen hebben we al onze komponenten gebruikt op een breadboard, deze breadboard dient dan als testobject zodat we niet meteen in de behuizing te werk moeten gaan. Lai parādītu prototipu, mēs to uzzinājām, izmantojot tīmekļa vietni tinkercad.com, op deze manier hadden we een duidelijk overzicht van ons prototype dat elk groepslid ook kon bewerken.

Šeit ir 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. Jaunas gaismas diodes lampas dienen gewoon als visuele controle om er zeker van te zijn dat de interactie succesvol werkt.

3. solis: koda prototips

Globale variabelen

In e erste deel van de de code initialiseer je globale variabelen voor de pins van arduino uno waar alle pushbuttons mee verbonden zijn.

// zet pin numuri waar mainButton (snaar) lv andere pogas aan verbonden zijn: const int mainButton = A1; // gitaar snaar const int lightSensor = A0; const int pogaPin1 = 2; // nummer van pushbutton1 const int buttonPin2 = 3; // nummer van pushbutton2const int pogaPin3 = 4; // nummer van pushbutton3const int buttonPin4 = 5; // nummer van pushbutton4const int pogaPin5 = 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; // gaismas diodes tapas numurs 13

const int ledPin2 = 12; // LED tapas skaits 12 const int ledPin3 = 11; // LED tapas skaits 11 const int ledPin4 = 10; // LED tapas skaits 10 const int ledPin5 = 9; // LED tapas skaits 9 const int potPin = A5; // LED tapas A5 skaits

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

Uzstādīt

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 ir komentārs geschreven wat er concreet gedaan wordt. Papildu uitleg over wat een specificieke functie concreet doet is te vinden in de arduino reference

void setup () {// datu pārraides ātrums sekundē (baud) vai sērijas datu pārraide Serial.begin (9600); // Initialiseer de ledPin variabelen als output pinMode (ledPin1, OUTPUT); pinMode (ledPin2, OUTPUT); pinMode (ledPin3, OUTPUT); pinMode (ledPin4, OUTPUT); pinMode (ledPin5, OUTPUT); // inicializēt visas spiedpogas als input: pinMode (mainButton, INPUT); pinMode (buttonPin1, INPUT); pinMode (buttonPin2, INPUT); pinMode (buttonPin3, INPUT); pinMode (buttonPin4, INPUT); pinMode (buttonPin5, INPUT); pinMode (potPin, INPUT); pinMode (gaismas sensors, IEEJA); }

Tukša funkcija

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

// deklarētājs un masīvs mainStates en geef die de standaard waarden 0 in.

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

// cilpa virs masīva aantalKnoppen

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

4. solis: prototips 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 alle knoppen een reageie geven op de bijhorende ledjes en dat ook combinaties van knoppen mogelijk zijn.

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

5. solis: "ontmantelen" behuizing En Kijken Welke Componenten Gebruikt Gaan Worden

Als de code correct werkte op het prototype zijn we begonnen met het "ontmantelen" van onze Guitar Hero-gitaar. Mēs atradām ģitāras atvērtās darbības un uzzinājām, kādas ir šīs problēmas. 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 button gebruikt (zie vierde foto). De LEDjes zullen verdwijnen (deze waren enkel ter indicatie zodat we zagen dat alle knoppen right werkten).

6. solis: Werking Originele Pogas + Dremelen

Bijušo videoklipu videoklips ir pieejams, lai uzzinātu, vai tas ir oriģināls, un tas tiek darīts sākotnēji.

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. solis: Bedrading Solderen + Pogas Vastlijmen

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

8. solis: Plats Maken De Behuizing

Omdat dit Guitar Hero-model redelijk krap was om mee te werken hebben we extra plaats moeten maken d.m.v. drūms. 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 pogas 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 met de Arduino door een gat in de onderkant van de gitaar de behuizing verlaten.

9. solis: Bedrading Aansluiten Op Protobord

Om alle componentsen 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 effectië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).

10. solis: Verstevigen

Kā arī pēdējais pieskāriens ir verstandig om de losse delen te verstevigen voor extra stabiliteit. 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.

11. solis: Code Voor Het Communiceren Met Reaper

Deze kods ir pieejams divās daļās, bet eerste deel ir de arduino IDE (interaktīvā attīstības vide). Kodu teksts 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.

Apstrāde notiek pēc tweede gedeelte. Deze code dient om alles wat arduino doortuurt te ontvangen en door te sturen naar Reaper.

Arduino

/* Šis kods ir pamata skice saziņai ar apstrādi, izmantojot seriālu.

Tas ir plāns, kurā varat ievietot savu kodu

norādīts jūsu pogām, potenciometriem vai sensoriem.

Tam ir rokasspiediens, lai pārliecinātos, ka mums ir kontakts

un tiek noteikts formāts, kādā mēs sazināmies

Ir svarīgi vēstījumu veidot tādā pašā veidā, lai apstrāde zinātu, kā to dekonstruēt un nosūtīt pareizus OSC ziņojumus mūsu DAW

paredzēts darba kolekcijai AV&IT

oktobris 2017

*

/ pārraides ātrumu

const garš baudRate = 115200;

// laiks gaidīt ms starp aptaujām līdz tapām

const int loopPauseTime = 200; // mili sekundes

// Serial nosūtītā ziņojuma sākuma un beigu vērtības

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

const char contactCharacter = '|';

// pin id's

// citi globālie mainīgie

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;

// analoģijas sensori

const int potPin = A5; // pin voor tremolo

// Šī funkcija mums ir nepieciešama, lai izveidotu kontaktu ar apstrādes skici

// Saglabājiet to šeit void createContact () {while (Serial.available () <= 0) {Serial.print (contactCharacter); // nosūtīt simbolu un gaidīt atbildi… delay (loopPauseTime); } Sērijas.lasījums (); }

void setup () {

// iestatiet pinModes visām tapām (int i = 0; i <aantalKnoppen; i ++) {pinMode (knopPinnen , INPUT); } pinMode (mainButton, INPUT); // nekomentēt, ja izmantojat sensorus, kas darbojas ar 3V, nevis 5V // // jums būs jāpievieno arī "ext" tapa līdz 3.3V // analogReference (EXTERNAL);

// inicializēt sērijas komentārus

Serial.begin (baudRate); kamēr (! Seriāls); // gaidiet rokasspiedienu izveidotContact (); }

void loop () {

// 1. SOLIS: LASIET POGAS // aptaujājiet visas tapas un kartējiet nolasījumu atbilstošā diapazonā 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); // piemēri: // float v0 = map (bpm, 0, 1023, 60, 250); // ja vēlaties izmantot normalizētu pludiņu (piemēram, skaļumam) // float v1 = map (analogRead (pin2), fromMin, fromMax, 0, 100) / 100.0;

// 2. SOLIS: RAKSTI ZIŅOJUMU

Serial.print (startString); // sākt ziņojumu secību (int i = 0; i <aantalKnoppen; i ++) {if (mainButtonState == HIGH) {Serial.print (namenKnoppen ); Serial.print (","); Serial.print (buttonStates ); ja (i <aantalKnoppen - 1) {Serial.print (","); }} cits {buttonStates = 0; Sērijas nospiedums (namenKnoppen ); Serial.print (","); Serial.print (buttonStates ); ja (i <aantalKnoppen - 1) {Serial.print (","); }}} Serial.print (","); Serial.print ("tremolo"); Serial.print (","); Serial.print (karte (potValue, 0, 1023, 0, 100)); // rakstīt ziņojuma beigas Serial.print (endString);

// pagaidi kādu laiku..

kavēšanās (loopPauseTime); }

Apstrāde

Atruna: Niet alle code van de feldolgēšanas skices staat hier in geschreven, voor de volledige code zie het bestand: ProcessingSoundControl_handout_v6_1.pde in bijlage

De volgende instrukcijas moeten aangepast worden (indien nodig):

// Baudrate moet hetzelfde zijn zoals in de arduino sketch

gala int baudRate = 115200;

// Zoek naar het IP adrese pļāvējā (zie ekrānuzņēmumi bijlage)

// Stuurt naar dit andres en reaper luistert hier naar apstrāde

// galīgā virkne remoteIP = "192.168.1.43"; // piem. "127.0.0.1";

final String remoteIP = "10.3.209.60";

// Ņemiet vērā sendPort un aizpildiet to Reaper.

// Tas ir ports, uz kuru apstrāde sūta un Reaper klausās.

gala int listenPort = 12000, sendPort = 12000;

// ListenPort šeit ir paredzēts aktīvai atkļūdošanai.

// arī portNames ir šeit, lai atkļūdotu.

// galīgā virkne portName = "/dev/ttyACM0";

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

////////////////////// LIETOTĀJA PARAMETRU BEIGAS //////////////////////// ////

importa apstrāde.sērija.*;

importēt java.util.*;

importēt oscP5.*;

importēt netP5.*;

OscP5 oscP5;

NetAddress myRemoteLocation;

Sērijas commsPort; // Sērijas ports

Būla ziņojumsArrived = false;

Ienākošā virkne = "", IncomingOSCMessage = "";

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

// Lai pārliecinātos, ka mēs nosūtām tikai tos parametrus (vērtības), kas mainās

// šie globālie variabls ir delcared šeit, bet // nevajadzētu šeit inicializēt! HashMap oldParams, newParams, toSendParams;

// Mums ir jāsadala ziņojums pie katra komata

void processIncoming () {String resVec = ienākošais.split (","); // mēs iegūstam vārdu+vērtību pārus // tāpēc katram vārdam (+2)… mēģiniet {par (int i = 0; i <resVec.length; i+= 2) {float value = Float.parseFloat (resVec [i+ 1]); // ievietojiet tos jaunajā Hashtable newParams.put (resVec , vērtība); }} // ja rodas kļūda, pieņemsim to parādīt un iziet. catch (Exception ex) {println ("Izņēmuma ziņojums:" + ex); printArray (resVec); Izeja(); }}

// Lai filtrētu mūsu ziņojumus

/ * Mēs pārliecināmies, ka OSC izejas ziņojums ir tikai tad, kad * tiek mainīts ievades ziņojums (sērijas). * Tātad mēs filtrējam ienākošās vērtības, kas faktiski mainās. * Piezīme: mēs neizvairīsimies no lecīgām vērtībām *, piemēram, no akselerometriem vai attāluma sensoriem HashMap (); for (String key: newParams.keySet ()) {// ja atslēga jau ir, ja (oldParams.containsKey (key)) {// atslēga ir klāt un vērtība nav vienāda, tad atjauniniet, ja (! oldParams.get (key).equals (newParams.get (key))) {toSendParams.put (key, newParams.get (key)); }} cits {// atslēga nav vecos parametros, tāpēc ielieciet to! toSendParams.put (atslēga, newParams.get (atslēga)); } oldParams.put (atslēga, newParams.get (atslēga)); }}

void makeOSC () {

for (String key: toSendParams.keySet ()) {OscMessage myMessage = new OscMessage ("/"+ key); myMessage.add (toSendParams.get (atslēga)); / * nosūtīt ziņojumu */ oscP5.send (myMessage, myRemoteLocation); }}

void translateMessage () {

processIncoming (); filterParams (); makeOSC (); } // Kad vēlamies izdrukāt logā void ShowIncoming () {// lai redzētu ienākošo ziņojumu, kā tas ir noteikts HashMap tekstā ("Ienākošais no Arduino", 20, 20); int y = 20; for (String key: newParams.keySet ()) {y = y+20; teksts (taustiņš, 20, y); teksts (newParams.get (atslēga), 300, y); }}

void showOsc () {

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

void setup () {

izmērs (1000, 800); // Skatuves lieluma aizpildījums (255); fons (0); oldParams = jauns HashMap (); newParams = jauns HashMap (); // printArray (Serial.list ()); commsPort = jauns seriāls (šis, porta nosaukums, baudas ātrums);

/ * sāciet oscP5, klausoties ienākošos ziņojumus */

oscP5 = jauns OscP5 (šis, listenPort);

/* myRemoteLocation ir NetAddress. NetAddress izmanto 2 parametrus, * ip adrese un porta numurs.myRemoteLocation tiek izmantots kā parametrs * oscP5.send (), nosūtot osc paketes uz citu datoru, ierīci, * lietojumprogrammu. lietojumu skatīt zemāk. pārbaudes nolūkos klausīšanās ports * un attālās atrašanās vietas adreses ports ir vienādi, tāpēc jūs * nosūtīsit ziņojumus atpakaļ uz šo skici. */ myRemoteLocation = jauna NetAddress (remoteIP, sendPort); }

void draw () {

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

void serialEvent (Serial commsPort) {

// nolasīt baitu no seriālā porta: char inChar = commsPort.readChar (); switch (inChar) {case contactCharacter: commsPort.write (contactCharacter); // lūgt vairāk println ("sākot …"); pārtraukums; gadījums startChar: ienākošais = ""; pārtraukums; case endChar: messageArrived = true; // println ("ziņojuma beigas"); pārtraukums; noklusējums: ienākošais += inChar; pārtraukums; }}

/* ienākošais osc ziņojums tiek pārsūtīts uz metodi oscEvent. */

void oscEvent (OscMessage theOscMessage) {float value = theOscMessage.get (0).floatValue (); // iegūt 1. osc argumentu

IncomingOSCMessage += "\ n" +

String.format ("### saņēma osc ziņojumu:" + "addrpattern:" + theOscMessage.addrPattern () + ": %f", vērtība); println (IncomingOSCMessage); }

12. solis: kontrolieris Uittesten

Nu alles ir aangesloten, all code is geschreven en alles is gedubbelcheckt is het eindelijk tijd om de controller z'n werk te laten doen. Zoek een paar leuke effecten Reaper en geniet van de voltooide Guitar Hero MIDI Controller!