Controlador retro: 7 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:16

Wij zijn eerste jaar studenten uit of 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.

Pas 1: Wat Heb Je Nodig?

Componenten

- 2 botons;

- 2 metres Potentio;

- 2 comprensions (1K alces);

- Arduino uno / nano

- Draadjes (esquema zie elektronisch)

- Soldeerplaat

- Plaqueta de MDF

Eines

- Trencaclosques

- Kniptang

- Striptang

- Soldeerbout (met llauna)

Programes

- Il·lustrador / indesign (Tekenprogramma)

- Segador

- Tramitació

- Arduino

Pas 2: processament del codi

/**

* Esbós bàsic per rebre missatges serials d'Arduino * i els tradueix a missatges OSC per a Reaper * * Haureu d'adaptar els PARÀMETRES D'USUARI * i haureu d'instal·lar una biblioteca: oscP5 * * feta per werkcollege AV&IT * per annoo bob eddi * oct 2017 * * / ///////////////////// PARÀMETRES D'USUARI //////////////////// ////////

/ assegureu-vos que utilitzeu la mateixa velocitat de transmissió al vostre croquis Arduino final int baudRate = 115200;

// Aneu a buscar l'adreça IP a Reaper quan utilitzeu OSC // Aquesta és l'adreça que el processament envia i la que escolta Reaper. // Poseu aquesta cadena a remoteIP, aquí.

// final String remoteIP = "192.168.1.43"; //per exemple. "127.0.0.1";

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

// Pren nota del sendPort i emplena-ho a Reaper. // Aquest és el port que envia Processing i escolta Reaper.

final int listenPort = 11000, sendPort = 12000;

// El ListenPort aquí és per depurar activament.

// els portNames també són aquí per depurar-los.

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

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

///////////////////// FI DE PARÀMETRES D'USUARI ///////////////////////// ////

processament de la importació. sèrie. *; importa java.util. *;

importació oscP5. *; importar netP5. *;

OscP5 oscP5; NetAddress myRemoteLocation;

Comunicacions en sèrie; // El missatge booleà del port sèrie Arrivat = fals;

String incoming = "", IncomingOSCMessage = "";

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

// Per assegurar-nos que només enviem els paràmetres (valors) que canvien // aquestes variables globals són descarregades aquí, però // no s’han d’inicialitzar aquí. HashMap oldParams, newParams, toSendParams;

// Hem de dividir el missatge a cada procés de coma void processIncoming () {String resVec = incoming.split (","); // obtenim parells nom + valor // així que per a cada nom (+2) … proveu {for (int i = 0; i <resVec.length; i + = 2) {float value = Float.parseFloat (resVec [i + 1]); // col·loqueu-los al nou Hashtable newParams.put (resVec , valor); }} // si es produeix un error, capturem la visualització i la sortida. catch (Exception ex) {println ("Missatge d'excepció:" + ex); printArray (resVec); sortir (); }}

// Per filtrar els nostres missatges / * Ens assegurem que només hi hagi un missatge OSC-out quan * canviï el missatge d'entrada (sèrie) * És a dir: si girem / premem el botó i canvia de valor. * Per tant, filtrem els valors entrants que realment canvien * nota: no evitarem saltar els valors * ja que provenen, per exemple, d’acceleròmetres o de sensors de distància *, haureu de suavitzar-los vosaltres mateixos a Arduino * / void filterParams () {toSendParams = new HashMap (); for (Clau de cadena: newParams.keySet ()) {// si la clau ja està present si (oldParams.containsKey (key)) {// key present i el valor no és el mateix, actualitzeu if (! oldParams.get (key).equals (newParams.get (key))) {toSendParams.put (key, newParams.get (key)); }} else {// la clau no està present en paràmetres antics, així que poseu-la! toSendParams.put (clau, newParams.get (clau)); } oldParams.put (clau, newParams.get (clau)); }}

void makeOSC () {for (Clau de cadena: toSendParams.keySet ()) {OscMessage myMessage = new OscMessage ("/" + key); myMessage.add (toSendParams.get (key)); / * enviar el missatge * / oscP5.send (myMessage, myRemoteLocation); }}

void translateMessage () {processIncoming (); filterParams (); makeOSC (); } // Quan volem imprimir a la finestra buida ShowIncoming () {// per veure el missatge entrant, tal com s’estableix al text de HashMap ("Incoming from Arduino", 20, 20); int y = 20; per a (Clau de cadena: newParams.keySet ()) {y = y + 20; text (clau, 20, y); text (newParams.get (clau), 300, y); }}

void showOsc () {text (missatge entrantOSC, 300, 200); IncomingOSCMessage = ""; }

void setup () {mida (1000, 800); // Omplir la mida de l’etapa (255); fons (0); oldParams = nou HashMap (); newParams = nou HashMap (); // printArray (Serial.list ()); commsPort = sèrie nova (this, portName, baudRate);

/ * iniciar oscP5, escoltant els missatges entrants * / oscP5 = OscP5 nou (això, listenPort);

/ * myRemoteLocation és una adreça de xarxa. un NetAddress té 2 paràmetres, * una adreça IP i un número de port. myRemoteLocation s’utilitza com a paràmetre a * oscP5.send () quan s’envien paquets osc a un altre ordinador, dispositiu o aplicació *. ús veure més avall. a efectes de prova, el port d'escolta * i el port de l'adreça d'ubicació remota són els mateixos, de manera que * envieu missatges a aquest esbós. * / myRemoteLocation = newAddress Net (IP remot, sendPort); }

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

void serialEvent (Serial commsPort) {// llegeix un byte des del port sèrie: char inChar = commsPort.readChar (); switch (inChar) {caseCaracter contact: commsPort.write (contactCharacter); // demana més println ("començant …"); trencar; case startChar: entrant = ""; trencar; case endChar: messageArrived = true; // println ("final de msg"); trencar; per defecte: entrant + = inChar; trencar; }}

/ * els missatges osc entrants es reenvien al mètode oscEvent. * / void oscEvent (OscMessage theOscMessage) {float value = theOscMessage.get (0).floatValue (); // obtenir el primer argument osc

IncomingOSCMessage + = "\ n" + String.format ("### ha rebut un missatge osc:" + "addrpattern:" + theOscMessage.addrPattern () + ":% f", valor); println (IncomingOSCMessage); }

Pas 3: Codi Arduino

/ * Aquest codi és un esbós bàsic per comunicar-se amb el processament mitjançant sèrie.

És un pla en què podeu posar el vostre propi codi especificat per als vostres propis botons, potenciòmetres o sensors.

Té una encaixada de mans per assegurar-nos que tenim contacte i es decideix el format en què ens comuniquem

És important construir el missatge d'aquesta manera, de manera que Processing sàpiga desconstruir-lo i enviar missatges OSC correctes al nostre DAW.

fet per werkcollege AV&IT octubre de 2017

code smooothing creat el 22 d'abril de 2007 per David A. Mellis modificat el 9 d'abril de 2012 per Tom Igoe

*/

/ baud rate const long baudRate = 115200;

// temps per esperar en ms entre enquestes als pins const int loopPauseTime = 200; // mil·lis segons

// valors d'inici i finalització del missatge enviat a Serial const String startString = "*", endString = "#";

const char contactCharacter = '|';

// pin int's const int buttonPin1 = 2; const int buttonPin2 = 5; const int numLectures = 5; // valora l’allisament de les furgonetes

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

// altres variables globals int buttonState1 = 0; int buttonState2 = 0; // variable per llegir el sensor flotant d'estat del polsador Valor1 = 0; float sensorValue2 = 0; Valor sensor3 flotant = 0;

// suavitzar les lectures int [numLectures]; // les lectures de l'entrada analògica int readIndex3 = 0; // l’índex de la lectura actual int total3 = 0; // la mitjana flotant total en curs3 = 0; // la mitjana

// Necessitem aquesta funció per establir contacte amb l'esbós de processament // Mantingueu-lo aquí buit establirContact () {while (Serial.available () <= 0) {Serial.print (contactCharacter); // envieu un caràcter i espereu una resposta … demora (loopPauseTime); } Serial.read (); }

void setup () {// defineix els pinModes per a tots els pins pinMode (buttonPin1, INPUT); pinMode (buttonPin2, INPUT); pinMode (pitchReading, INPUT); pinMode (speedReading, INPUT); pinMode (infraLectura, INPUT);

// inicialitzar comunicacions de sèrie Serial.begin (baudRate); mentre que (! sèrie); // suavitzant per (int thisReading = 0; thisReading <numReadings; thisReading ++) {lectures [thisReading] = 0; }

// esperar encaixada de mans establirContact (); }

void loop () {// sondeja tots els pins i assigna la lectura al rang adequat buttonState1 = digitalRead (buttonPin1); buttonState2 = DigitalRead (buttonPin2); sensorValue1 = analogRead (pitchReading); sensorValue2 = analogRead (velocitat de lectura); sensorValue3 = analogRead (infraLectura);

// assignar els valors entrants als valors necessaris sensorValue1 = mapa (sensorValue1, 0, 1023, 0, 100.0) / - 100.0; sensorValue2 = mapa (sensorValue2, 0, 1023, 0,0, 100) /100,0; ValorSensor3 = mapa (ValorSensor3, 0, 700, 50, 100);

// sensor de suavitzat: total3 = total3 - lectures [readIndex3]; // llegir des del sensor: lectures [readIndex3] = sensorValue3; // afegiu la lectura al total: total3 = total3 + lectures [readIndex3]; // avançar a la següent posició a la matriu: readIndex3 = readIndex3 + 1;

// si ens trobem al final de la matriu … if (readIndex3> = numReadings) {// … arrodoneu-vos al principi: readIndex3 = 0; } // calcula la mitjana: mitjana3 = (total3 / numLectures); // sensor de suavitzat

Serial.print (startString); // iniciar una seqüència de missatges // wirteu tot el nom, els parells de valors, separats per comes Serial.print ("potentio1"); Serial.print (","); Serial.print (sensorValue1); Serial.print (",");

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

Serial.print ("infra-sensor"); Serial.print (","); Serial.print (mitjana3 / 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);

// escriure el final del missatge Serial.print (endString);

// Espera un moment..

delay (loopPauseTime); }

Pas 4: Segador

Etapa 1: Ga bovenaan naar Opcions> Preferències

Stap 2: Ga in prefrences naar Control / OSC / web en druk op Add

Etapa 3: mode de superfície de control Kies bij per a OSC (control de so obert)

Stap 4: Vul je nom del dispositiu, vink Rebre al port aan en vul a l'aigua en processar bij Sendport staat

Etapa 5: la còpia de l'adreça IP de l'amfitrió es troba en procés de processament

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

Pas 5: Behuizing

Breedte: 170 mm

Llargada: 90 mm

Hoogte 30 mm

Knoppen: 16 mm (diàmetre

Potenciòmetres: 3 mm (diàmetre)

Sensor de suport: Breedte 2,9 mm

Llarg 0,8 mm

Material: MDF (3 mm)

Pas 6: Elektronica

Etapa 1:

Verbind de ground en 5 volt van Arduino met het breadboard

Etapa 2:

El pin de verb A0 i el poder 1

El pin de verb A1 i el potent 2

El pin A3 de Verbind es va trobar amb un sensor infrarood.

Botó enganxós del pin A2 del verbind.

El botó enganxós A5 del pin de verb.

Pas 7: Medewerkers

- Mayes El Baba

- Arno Gorissen

- Michiel De Wandelaer