Projeto Guitar Hero Arduino: 12 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:39

Wij zijn Maarten Vrebos, Justin Cavanas e Wannes Stroobandt en nós estudamos tecnologia de comunicação e multimídia. 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 estava onze bedoeling om de bestaande knoppen op de gitaar intern te vervangen. Onze controller zal vastgehouden e bespeeld worden als een normale gitaar. Aangezien we iets hebben gehackt hebben we er niet veel extra materiaal in moeten verwerken.

Em de afbeelding kan u onze allereerste schets em 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…

Projeto Benodigdheden voor dit

• 6 botões kleine
• 7 resistores de 1kohm
• 1 gele LED 1
• blauwe LED
• 1 Arduino Uno R3
• 1 LED groene
• 2 LEDs montados
• 1 schuifschakelaar
• 1 placa de ensaio
• 1 potenciômetro
• 1 protobord
• 1 Guitar Hero gitaar
• Voldoende bedrading
• Materiaal om te solderen / dremelen /
• Schroevendraaier

Etapa 1: Componenten Verzamelen

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

6 botões

7 resistores de 1kohm

1 LED amarelo

1 LED azul

1 Arduino Uno R3

1 LED verde

2 LED vermelho

1 Schuifschakelaar

1 breadboard

1 potenciômetro

Etapa 2: Protótipo de Bouwen

Om ons prototype te bouwen hebben we all onze componenten gebruikt op een breadboard, deze breadboard dient dan als testobject zodat we niet meteen in behuizing te werk moeten gaan. Este protótipo está disponível em 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 de meerdere 'snaren' moet worden ingedrukt om een auditief effect te krijgen. De verschillende LED-lampjes dienen gewoon als visuele control om er zeker van te zijn dat de interactie succesvol werkt.

Etapa 3: Protótipo de código

Variabelen global

No het eerste deel van de code initialiseer je global variabelen voor de pins van arduino uno waar allle pushbuttons mee verbonden zijn.

// zet os números dos pinos waar mainButton (snaar) e os botões andere aan verbonden zijn: const int mainButton = A1; // gitaar snaar const int lightSensor = A0; const int buttonPin1 = 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; // o número do pino 13 do LED

const int ledPin2 = 12; // o número do pino 12 do LED const int ledPin3 = 11; // o número do pino 11 do LED const int ledPin4 = 10; // o número do pino LED 10 const int ledPin5 = 9; // o número do pino 9 do LED const int potPin = A5; // o número do pino LED A5

De laatste globale variabelen dienen als 'states' voor de sensores (zijn de pushbuttons ingedrukt of niet? Potenciômetro, lichtsensor).

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

Configurar

Nu volgt de void setup functie. Deze é 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 () {// taxa de dados por segundo (baud) voor seriele data transmissie Serial.begin (9600); // Initialiseer de ledPin variabelen als output pinMode (ledPin1, OUTPUT); pinMode (ledPin2, OUTPUT); pinMode (ledPin3, OUTPUT); pinMode (ledPin4, OUTPUT); pinMode (ledPin5, OUTPUT); // inicializador de todos os botões de pressão também 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); }

Função void

Na de setup () functie volgt de loop () functie, de instructies die hierin staan gaan herhaald uitgevoerd worden.

void loop () {// limita o status dos botões de pressão uit (ingedrukt of niet) mainButtonState = digitalRead (mainButton); buttonState1 = digitalRead (buttonPin1); buttonState2 = digitalRead (buttonPin2); buttonState3 = digitalRead (buttonPin3); buttonState4 = digitalRead (buttonPin4); buttonState5 = digitalRead (buttonPin5);

// todos os status do botão de pressão na matriz een

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

// faz um loop sobre o array aantalKnoppen

para (int i = 0; i <aantalKnoppen; i ++) {pinMode (knopPinnen , INPUT); // inicializador todo knopPinnen als input digitalRead (knopPinnen ); // limita o valor de todos os knoppinnen uit // indien de mainswitch (snaar) ingedrukt é, imprime todos os knopnamen, todos os estados dos botões if (mainButtonState == HIGH) {Serial.print (namenKnoppen ); Serial.print (","); Serial.println (buttonStates ); }}

Etapa 4: Protótipo Uittesten

Nadat het prototype gebouwd é volgens ons model en de code geschreven está em 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.

No vídeo de tweede é te zien hoe onze tremolo werkt aan de hand van een potenciômetro em de gitaar en hoe de waardes worden uitgelezen em Processing.

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

Als de code correct werkte op het prototype zijn nós começamos a conhecer 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 pushbuttons in de bestaande buttons gekregen (zie volgende stap). We hebben de tremolo ook gebruikt voor ons eindproduct en voor onze hoofdbutton (botão initiële om als een combinatie af te spelen) hebben we ook de originele twee botões gebruikt (zie vierde foto). De LEDjes zullen verdwijnen (deze waren enkel ter indicatie zodat we zagen dat all knoppen correct werkten.

Etapa 6: Botões Werking 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.

Passo 7: Bedrading Solderen + Buttons 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.

Etapa 8: Plaats Maken em De Behuizing

Omdat disse que o modelo redelijk krap do Guitar Hero foi om mee te werken hebben we plaats extra 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 gegevente 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 draden die rechtstreeks verbonden worden met de Arduino door een gat in de onderkant van de gitaar de behuizing verlaten.

Etapa 9: Bedrading Aansluiten Op Protobord

Om alle componenten met elkaar te verbinden hebben we gebruik gemaakt van een protobord. Este é een bordje dat eigenlijk op net dezelfde manier werkt als een breadbord, maar dan betrouwbaarder eneficië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).

Etapa 10: Verstevigen

O toque final é het verstandig om de losse delen te verstevigen voor extra stabiliteit. Op deze foto is the zien hoe we het deel dat we er hebben uitgehaald d.m.v. dremelen achteraan de buttons verstevigen met stukjes karton.

Etapa 11: Code Voor Het Communiceren Met Reaper

Código Deze é opgedeeld em twee delen, het eerste deel está em de arduino IDE (ambiente de desenvolvimento interativo) geschreven. A palavra de código geüpload naar arduino zelf en dient om todos os waarden van de sensores van de midi controller uit te lezen en door to sturen naar processing.

O processamento é het tweede gedeelte. Deze code dient om alles wat arduino doorstuurt to ontvangen en door to sturen naar Reaper.

Arduino

/ * Este código é um esboço básico para se comunicar com o Processing through Serial.

É um projeto no qual você pode colocar seu próprio código

especificado para seus próprios botões, potenciômetros ou sensores.

Tem um aperto de mão para garantir que temos contato

e o formato em que estamos nos comunicando é decidido

É importante construir a mensagem da mesma maneira, para que Processing saiba como desconstruí-lo e enviar mensagens OSC corretas para nosso DAW

feito para werkcollege AV&IT

outubro de 2017

*

/ taxa de transmissão

const long baudRate = 115200;

// tempo de espera em ms entre as pesquisas para os pinos

const int loopPauseTime = 200; // milisegundos

// valores iniciais e finais para a mensagem enviada em Serial

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

const char contactCharacter = '|';

// pin id's

// outras variáveis globais

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;

// sensores analógicos

const int potPin = A5; // pin voor tremolo

// Precisamos desta função para estabelecer contato com o esboço de processamento

// Mantenha-o aqui void activateContact () {while (Serial.available () <= 0) {Serial.print (contactCharacter); // envia um char e espera por uma resposta… delay (loopPauseTime); } Serial.read (); }

void setup () {

// define os pinModes para todos os pinos para (int i = 0; i <aantalKnoppen; i ++) {pinMode (knopPinnen , INPUT); } pinMode (mainButton, INPUT); // descomente se você usar sensores que funcionam em 3 V em vez de 5 V // você terá que conectar o pino 'ext' a 3,3 V também // analogReference (EXTERNAL);

// inicializa a comunicação serial

Serial.begin (baudRate); while (! Serial); // aguarde o handshake EstablecerContato (); }

void loop () {

// PASSO 1: LEIA OS BOTÕES // pesquisa todos os pinos e mapeia a leitura para o intervalo apropriado 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); para (int i = 0; i <aantalKnoppen; i ++) {buttonStates = digitalRead (knopPinnen ); } potValue = analogRead (potPin); // exemplos: // float v0 = map (bpm, 0, 1023, 60, 250); // se você deseja usar um float normalizado (por exemplo, para o volume) // float v1 = map (analogRead (pin2), fromMin, fromMax, 0, 100) / 100.0;

// PASSO 2: ESCREVER MENSAGEM

Serial.print (startString); // inicia uma sequência de mensagem para (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 (map (potValue, 0, 1023, 0, 100)); // escreve o final da mensagem Serial.print (endString);

// espere um pouco..

atraso (loopPauseTime); }

Em processamento

Isenção de responsabilidade: 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 sketch

final int baudRate = 115200;

// Zoek naar het endereço IP no reaper (zie screenshots na bijlage)

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

// String final remoteIP = "192.168.1.43"; //por exemplo. "127.0.0.1";

final String remoteIP = "10.3.209.60";

// Anote o sendPort e preencha no Reaper.

// Esta é a porta para a qual o Processing envia e o Reaper escuta.

final int listenPort = 12000, sendPort = 12000;

// O listenPort aqui é para depurar ativamente.

// os portNames também estão aqui para depurar.

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

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

///////////////////////// END of USER PARAMETERS ///////////////////////////// ////

import processing.serial. *;

import java.util. *;

import oscP5. *;

import netP5. *;

OscP5 oscP5;

NetAddress myRemoteLocation;

Serial commsPort; // A porta serial

boolean messageArrived = false;

String de entrada = "", IncomingOSCMessage = "";

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

// Para garantir que enviamos apenas os parâmetros (valores) que mudam

// essas variáveis globais são delcaradas aqui, mas // não devem ser inicializadas aqui! HashMap oldParams, newParams, toSendParams;

// Precisamos dividir a mensagem a cada vírgula

void processIncoming () {String resVec = entrando.split (","); // obtemos pares nome + valor // então para cada nome (+2)… try {for (int i = 0; i <resVec.length; i + = 2) {float value = Float.parseFloat (resVec [i + 1]); // coloque-os no novo Hashtable newParams.put (resVec , value); }} // se ocorrer um erro, vamos exibi-lo e sair. catch (Exceção de exceção) {println ("Mensagem de exceção:" + ex); printArray (resVec); saída(); }}

// Para filtrar nossas mensagens

/ * Certificamo-nos de que há apenas uma mensagem de saída OSC quando * a mensagem de entrada (Serial) muda * Ou seja: se girarmos / apertarmos o botão e ele mudar o valor. * Portanto, filtramos os valores de entrada que realmente mudam * nota: não evitaremos valores saltados * como vêm de, por exemplo, acelerômetros ou sensores de distância * você precisará suavizá-los no Arduino * / void filterParams () {toSendParams = new HashMap (); for (String key: newParams.keySet ()) {// se a chave já estiver presente if (oldParams.containsKey (key)) {// chave presente e valor diferente, então atualize if (! oldParams.get (key)).equals (newParams.get (key))) {toSendParams.put (key, newParams.get (key)); }} else {// a chave não está presente nos parâmetros antigos, então coloque! toSendParams.put (key, newParams.get (key)); } oldParams.put (key, newParams.get (key)); }}

void makeOSC () {

for (String key: toSendParams.keySet ()) {OscMessage myMessage = new OscMessage ("/" + key); myMessage.add (toSendParams.get (key)); / * enviar a mensagem * / oscP5.send (myMessage, myRemoteLocation); }}

void translateMessage () {

processIncoming (); filterParams (); makeOSC (); } // Quando queremos imprimir na janela void ShowIncoming () {// para ver a mensagem recebida, conforme definido no texto HashMap ("Incoming from Arduino", 20, 20); int y = 20; for (String key: newParams.keySet ()) {y = y + 20; texto (chave, 20, y); texto (newParams.get (chave), 300, y); }}

void showOsc () {

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

void setup () {

tamanho (1000, 800); // Preenchimento do tamanho do palco (255); fundo (0); oldParams = new HashMap (); newParams = new HashMap (); // printArray (Serial.list ()); commsPort = novo Serial (this, portName, baudRate);

/ * iniciar oscP5, ouvindo mensagens recebidas * /

oscP5 = novo OscP5 (isto, listenPort);

/ * myRemoteLocation é um NetAddress. um NetAddress leva 2 parâmetros, * um endereço IP e um número de porta.myRemoteLocation é usado como parâmetro em * oscP5.send () ao enviar pacotes osc para outro computador, dispositivo, * aplicativo. uso veja abaixo. para fins de teste, a porta de escuta * e a porta do endereço do local remoto são iguais, portanto, você * enviará mensagens de volta para este esboço. * / myRemoteLocation = new NetAddress (remoteIP, sendPort); }

void draw () {

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

void serialEvent (Serial commsPort) {

// lê um byte da porta serial: char inChar = commsPort.readChar (); switch (inChar) {case contactCharacter: commsPort.write (contactCharacter); // pedir mais println ("começando…"); pausa; case startChar: entrando = ""; pausa; case endChar: messageArrived = true; // println ("fim da mensagem"); pausa; padrão: entrada + = inChar; pausa; }}

/ * as mensagens osc recebidas são encaminhadas para o método oscEvent. * /

void oscEvent (OscMessage theOscMessage) {float value = theOscMessage.get (0).floatValue (); // obtém o primeiro argumento osc

IncomingOSCMessage + = "\ n" +

String.format ("### recebeu uma mensagem osc:" + "addrpattern:" + theOscMessage.addrPattern () + ":% f", valor); println (IncomingOSCMessage); }

Etapa 12: Controlador Uittesten

Nu alles é aangesloten, todo o código é geschreven en alles é gedubbelcheckt é het eindelijk tijd om de controlador z'n werk te laten doen. Experimente o Reaper e faça o mesmo para o Guitar Hero MIDI Controller!