Controler retro: 7 pași

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

Wij zijn eerste jaar studenten uit de opleiding Multimedia & Communicatietechnologie (Multec) aan de Erasmushogeschool Brussel.

Samen hebben we een muziek controller gemaakt dat muziek kan starten / stoppen, de pitch kan verhogen, kan terugspoelen en nog meer.

Ons idee kwam van van een cassette, ons doel was om een controller te maken dat lijkt op een cassette.

Pasul 1: Wat Heb Je Nodig?

Componenten

- 2 butoane;

- 2 contoare Potentio;

- 2 înțelegeri (1K elk);

- Arduino uno / nano

- Draadjes (schema zie elektronisch)

- Soldeerplaat

- Placă MDF

Instrumente

- Lasercutter

- Kniptang

- Striptang

- Soldeerbout (met staniu)

Programele

- Ilustrator / indesign (Tekenprogramma)

- Secerător

- Prelucrare

- Arduino

Pasul 2: Procesarea codului

/**

* Schiță de bază pentru a primi mesaje seriale de la Arduino * și le traduce în mesaje OSC pentru Reaper * * Va trebui să adaptați PARAMETRII UTILIZATORULUI * și va trebui să instalați o Bibliotecă: oscP5 * * făcută pentru werkcollege AV&IT * de annoo bob eddi * oct 2017 * * / ///////////////////// PARAMETRI UTILIZATORI ////////////////////// ////////

/ asigurați-vă că utilizați aceeași rată baud în schița dvs. Arduino final int baudRate = 115200;

// Du-te și caută adresa IP în Reaper când folosești OSC // Aceasta este adresa de procesare pe care o trimite și Reaper o ascultă. // Puneți acest șir în remoteIP, aici.

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

final String remoteIP = "vul hier ip in gevonden in reaper";

// 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 = 11000, sendPort = 12000;

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

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

final String portName = "vul hier de portname in gevonden in Arduino";

// final String portName = "COM6"; // "/ 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;

String incoming = "", IncomingOSCMessage = "";

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

// Pentru a ne asigura că trimitem doar parametrii (valorile) care se schimbă // 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ă 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 atunci 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 = ""; }

setare 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 = OscP5 nou (acesta, listenPort);

/ * myRemoteLocation este un NetAddress. un NetAddress are 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); }

void draw () {if (messageArrived) {fundal (0); translateMessage (); ShowIncoming (); messageArrived = false; } showOsc (); }

void serialEvent (Serial commsPort) {// citește 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 3: Cod Arduino

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

Este un plan în care 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 și este decis formatul în care comunicăm

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

făcut pentru werkcollege AV&IT oct 2017

cod smooothing creat la 22 aprilie 2007 de David A. Mellis modificat la 9 aprilie 2012 de Tom Igoe

*/

/ baud rate const long baudRate = 115200;

// timpul de așteptare în ms între sondaje la pinii 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 = '|';

// pin ID's const int buttonPin1 = 2; butonul const intPin2 = 5; const int numCitiri = 5; // evaluează netezirea vanului

int pitchReading = A1; int speedReading = A2; int infraCitire = A3;

// alte variabile globale int buttonState1 = 0; int buttonState2 = 0; // variabilă pentru citirea senzorului plutitor de stare al butonului Valoare1 = 0; senzor plutitor Valoare2 = 0; senzor plutitor Valoare3 = 0;

// netezirea citirilor int [numReadings]; // citirile din intrarea analogică int readIndex3 = 0; // indicele citirii curente int total3 = 0; // media float totală executată3 = 0; // media

// Avem nevoie de această funcție pentru a stabili contactul cu schița de procesare // Păstrați-l aici nul establizațiContact () {while (Serial.available () <= 0) {Serial.print (contactCharacter); // trimiteți un caracter și așteptați un răspuns … întârziere (loopPauseTime); } Serial.read (); }

void setup () {// setează pinMode-urile pentru toate pin-urile pinMode (buttonPin1, INPUT); pinMode (buttonPin2, INPUT); pinMode (pitchReading, INPUT); pinMode (speedReading, INPUT); pinMode (infraReading, INPUT);

// inițializează Serial comms Serial.begin (baudRate); while (! Serial); // netezire pentru (int thisReading = 0; thisReading <numReadings; thisReading ++) {lecturi [thisReading] = 0; }

// așteptați strângerea de mână, stabilițiContact (); }

void loop () {// sondează toți pinii și mapează citirea la intervalul corespunzător buttonState1 = digitalRead (buttonPin1); buttonState2 = digitalRead (buttonPin2); sensorValue1 = analogRead (pitchReading); sensorValue2 = analogRead (speedReading); sensorValue3 = analogRead (infraCitire);

// maparea valorilor primite la valorile necesare sensorValue1 = map (senzorValue1, 0, 1023, 0, 100.0) / - 100.0; sensorValue2 = hartă (sensorValue2, 0, 1023, 0,0, 100) /100,0; sensorValue3 = hartă (sensorValue3, 0, 700, 50, 100);

// senzor de netezire: total3 = total3 - citiri [readIndex3]; // citit de la senzor: lecturi [readIndex3] = sensorValue3; // adaugă citirea la total: total3 = total3 + citiri [readIndex3]; // avansați la următoarea poziție din matrice: readIndex3 = readIndex3 + 1;

// dacă suntem la sfârșitul matricei … if (readIndex3> = numReadings) {// … încheie la început: readIndex3 = 0; } // calculați media: medie3 = (total3 / numCitiri); // senzor de netezire

Serial.print (startString); // începe o secvență de mesaje // introduceți toate numele, perechile de valori, separate prin virgule Serial.print ("potentio1"); Serial.print (","); Serial.print (sensorValue1); Serial.print (",");

Serial.print ("potentio2"); Serial.print (","); Serial.print (sensorValue2); Serial.print (",");

Serial.print ("infra-senzor"); Serial.print (","); Serial.print (medie3 / 100); Serial.print (",");

Serial.print ("knop 1 in2 wit"); Serial.print (","); Serial.print (buttonState1); Serial.print (","); Serial.print ("knop2 in5 geel"); Serial.print (","); Serial.print (buttonState2);

// scrie sfârșitul mesajului Serial.print (endString);

// așteptați un timp..

întârziere (loopPauseTime); }

Pasul 4: secerător

Etapa 1: Opțiuni> Preferențe

Etapa 2: Ga în preferații naar Control / OSC / web en druk op Add

Etapa 3: Kies bij Modul suprafeței de control pentru OSC (Open Sound Control)

Etapa 4: Vul je numele dispozitivului în, vink Primiți pe portul în vul în apă în procesarea bi Sendport staat

Etapa 5: Copiază de Host IP este în stare de lucru în procesare

Stap 6: Druk op ok en de controller is nu verbonden met Reaper

Pasul 5: Behuizing

Breedte: 170 mm

Lungime: 90 mm

Hoogte 30 mm

Knoppen: 16 mm (diametru

Potentio metri: 3 mm (diametru)

Senzor afstand: Breedte 2,9 mm

Lungime 0,8 mm

Materiale: MDF (3mm)

Pasul 6: Elektronica

Etapa 1:

Verbind de ground în 5 volt van Arduino met het breadboard

Etapa 2:

Verbind pin A0 met potentio 1

Verbind pin A1 și potentio 2

Pinul verbal A3 a întâlnit senzorul infraroșu.

Verbind pin A2 met de niet buton lipicios.

Verbind pin A5 și butonul lipicios.

Pasul 7: Medewerkers

- Mayes El Baba

- Arno Gorissen

- Michiel De Wandelaer