Controlador retro: 7 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:44

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

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

En un casete idee kwam van van een, ons doel era om een controller te maken dat lijkt op een casete.

Paso 1: ¿Wat Heb Je Nodig?

Componente

- 2 botones;

- 2 medidores Potentio;

- 2 weerstanden (alce 1K);

- Arduino uno / nano

- Draadjes (esquema zie elektronisch)

- Soldeerplaat

- Plato de MDF

Instrumentos

- Cortador láser

- Kniptang

- Striptang

- Soldeerbout (met estaño)

Programación

- Ilustrator / indesign (Tekenprogramma)

- Segador

- Procesando

- Arduino

Paso 2: procesamiento de código

/**

* Esquema básico para recibir mensajes seriales de Arduino * y los traduce a mensajes OSC para Reaper * * Necesitarás adaptar los PARÁMETROS DE USUARIO * y necesitarás instalar una Biblioteca: oscP5 * * hecho para werkcollege AV&IT * por annoo bob eddi * oct 2017 * * / ///////////////////// PARÁMETROS DE USUARIO ////////////////////// ////////

/ asegúrese de usar la misma velocidad en baudios en su boceto de Arduino final int baudRate = 115200;

// Vaya y busque la dirección IP en Reaper cuando use OSC // Esta es la dirección a la que Processing envía y Reaper escucha. // Pon esta cadena en remoteIP, aquí.

// final String remoteIP = "192.168.1.43"; //p.ej. "127.0.0.1";

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

// Toma nota del sendPort y completa esto en Reaper. // Este es el puerto al que Processing envía y Reaper escucha.

final int listenPort = 11000, sendPort = 12000;

// El listenPort aquí es para depurar activamente.

// los portNames también están aquí para depurar.

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

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

/////////////////////// FIN DE PARÁMETROS DE USUARIO ///////////////////////// ////

procesamiento de importación.serie. *; importar java.util. *;

importar oscP5. *; importar netP5. *;

OscP5 oscP5; NetAddress myRemoteLocation;

CommsPort serial; // El puerto serial booleano messageArrived = false;

Cadena entrante = "", EntranteOSCMessage = "";

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

// Para asegurarnos de que solo enviamos los parámetros (valores) que cambian // ¡estas variables globales se eliminan aquí, pero // no deberían inicializarse aquí! HashMap oldParams, newParams, toSendParams;

// Necesitamos dividir el mensaje en cada coma void processIncoming () {String resVec = entrante.split (","); // obtenemos pares de nombre + valor // entonces para cada nombre (+2)… intente {for (int i = 0; i <resVec.length; i + = 2) {float value = Float.parseFloat (resVec [i + 1]); // ponerlos en el nuevo Hashtable newParams.put (resVec , value); }} // si se produce un error, capturémoslo y salgamos. catch (Exception ex) {println ("Mensaje de excepción:" + ex); printArray (resVec); Salida(); }}

// Para filtrar nuestros mensajes / * Nos aseguramos de que solo haya un mensaje de salida OSC cuando * el mensaje de entrada (Serial) cambia * Es decir: si giramos / pulsamos el botón y cambia de valor. * Así que filtramos los valores entrantes que realmente cambian * nota: no evitaremos saltos de valores * como provienen, por ejemplo, de acelerómetros o sensores de distancia * necesitará suavizarlos usted mismo en Arduino * / void filterParams () {toSendParams = new HashMap (); for (String key: newParams.keySet ()) {// si la clave ya está presente if (oldParams.containsKey (key)) {// clave presente y el valor no es el mismo, entonces actualice if (! oldParams.get (key).equals (newParams.get (clave))) {toSendParams.put (clave, newParams.get (clave)); }} else {// la clave no está presente en los parámetros antiguos, ¡así que póngala! toSendParams.put (clave, newParams.get (clave)); } oldParams.put (clave, newParams.get (clave)); }}

void makeOSC () {for (String key: toSendParams.keySet ()) {OscMessage myMessage = new OscMessage ("/" + tecla); myMessage.add (toSendParams.get (clave)); / * enviar el mensaje * / oscP5.send (myMessage, myRemoteLocation); }}

void translateMessage () {processIncoming (); filterParams (); makeOSC (); } // Cuando queremos imprimir en la ventana void ShowIncoming () {// para ver el mensaje entrante, como se establece en el texto HashMap ("Incoming from Arduino", 20, 20); int y = 20; for (String key: newParams.keySet ()) {y = y + 20; texto (tecla, 20, y); texto (newParams.get (clave), 300, y); }}

void showOsc () {texto (Mensaje OSCM entrante, 300, 200); IncomingOSCMessage = ""; }

configuración vacía () {tamaño (1000, 800); // Relleno del tamaño del escenario (255); fondo (0); oldParams = new HashMap (); newParams = new HashMap (); // printArray (Serial.list ()); commsPort = new Serial (this, portName, baudRate);

/ * inicia oscP5, escuchando mensajes entrantes * / oscP5 = new OscP5 (this, listenPort);

/ * myRemoteLocation es una NetAddress. una NetAddress toma 2 parámetros, * una dirección IP y un número de puerto. myRemoteLocation se usa como parámetro en * oscP5.send () cuando se envían paquetes osc a otra computadora, dispositivo, * aplicación. uso ver a continuación. para fines de prueba, el puerto de escucha * y el puerto de la dirección de ubicación remota son los mismos, por lo que * enviará mensajes a este boceto. * / myRemoteLocation = nueva NetAddress (remoteIP, sendPort); }

dibujar vacío () {if (mensajeArrivado) {fondo (0); translateMessage (); ShowIncoming (); messageArrived = falso; } showOsc (); }

void serialEvent (Serial commsPort) {// leer un byte del puerto serial: char inChar = commsPort.readChar (); switch (inChar) {caso contactCharacter: commsPort.write (contactCharacter); // pide más println ("comenzando…"); rotura; case startChar: entrante = ""; rotura; case endChar: messageArrived = true; // println ("fin del mensaje"); rotura; predeterminado: entrante + = inChar; rotura; }}

/ * Los mensajes osc entrantes se reenvían al método oscEvent. * / void oscEvent (OscMessage theOscMessage) {valor flotante = theOscMessage.get (0).floatValue (); // obtiene el primer argumento osc

IncomingOSCMessage + = "\ n" + String.format ("### recibió un mensaje osc:" + "addrpattern:" + theOscMessage.addrPattern () + ":% f", valor); println (Mensaje OSCM entrante); }

Paso 3: Codifica Arduino

/ * Este código es un boceto básico para comunicarse con Processing a través de Serial.

Es un plano en el que puede poner su propio código especificado para sus propios botones, potenciómetros o sensores.

Tiene un apretón de manos para asegurarnos que tenemos contacto y se decide el formato en el que nos estamos comunicando

Es importante construir el mensaje de la misma manera, para que Processing sepa cómo deconstruirlo y enviar mensajes OSC correctos a nuestra DAW.

hecho para werkcollege AV&IT oct 2017

suavizado de código creado el 22 de abril de 2007 por David A. Mellis modificado el 9 de abril de 2012 por Tom Igoe

*/

/ velocidad en baudios const long baudRate = 115200;

// tiempo de espera en ms entre sondeos a los pines const int loopPauseTime = 200; // milisegundos

// valores inicial y final para el mensaje enviado en Serial const String startString = "*", endString = "#";

const char contactCharacter = '|';

// pin id's const int buttonPin1 = 2; const int buttonPin2 = 5; const int numReadings = 5; // tasa de suavizado de furgonetas

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

// otras variables globales int buttonState1 = 0; int buttonState2 = 0; // variable de lectura del estado del pulsador float sensorValue1 = 0; flotador sensorValue2 = 0; flotador sensorValue3 = 0;

// suavizar las lecturas int [numReadings]; // las lecturas de la entrada analógica int readIndex3 = 0; // el índice de la lectura actual int total3 = 0; // el promedio flotante total acumulado3 = 0; // la media

// Necesitamos esta función para establecer contacto con el esquema de procesamiento // Guárdelo aquí void estabContact () {while (Serial.available () <= 0) {Serial.print (contactCharacter); // envía un carácter y espera una respuesta… delay (loopPauseTime); } Serial.read (); }

void setup () {// establece los pinModes para todos los pines pinMode (buttonPin1, INPUT); pinMode (buttonPin2, ENTRADA); pinMode (lectura de tono, ENTRADA); pinMode (lectura de velocidad, ENTRADA); pinMode (infraReading, INPUT);

// inicializar las comunicaciones en serie Serial.begin (baudRate); mientras (! Serial); // suavizado para (int thisReading = 0; thisReading <numReadings; thisReading ++) {lecturas [thisReading] = 0; }

// espera a que se establezca el protocolo de enlace (); }

void loop () {// sondear todos los pines y asignar la lectura al rango apropiado buttonState1 = digitalRead (buttonPin1); buttonState2 = digitalRead (buttonPin2); sensorValue1 = analogRead (lectura de tono); sensorValue2 = analogRead (speedReading); sensorValue3 = analogRead (infraReading);

// mapeo de los valores entrantes a los valores necesarios sensorValue1 = map (sensorValue1, 0, 1023, 0, 100.0) / - 100.0; sensorValue2 = mapa (sensorValue2, 0, 1023, 0.0, 100) /100.0; sensorValue3 = mapa (sensorValue3, 0, 700, 50, 100);

// sensor de suavizado: total3 = total3 - lecturas [readIndex3]; // leer del sensor: lecturas [readIndex3] = sensorValue3; // suma la lectura al total: total3 = total3 + lecturas [readIndex3]; // avanzar a la siguiente posición en la matriz: readIndex3 = readIndex3 + 1;

// si estamos al final de la matriz… if (readIndex3> = numReadings) {//… pasar al principio: readIndex3 = 0; } // calcula el promedio: average3 = (total3 / numReadings); // sensor de suavizado

Serial.print (startString); // iniciar una secuencia de mensajes // escribir todos los pares de nombres y valores, separados por comas 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 (","); Impresión serial (promedio3 / 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);

// escribe el final del mensaje Serial.print (endString);

// espera un rato..

delay (loopPauseTime); }

Paso 4: Reaper

Paso 1: Opciones de bovenaan naar> Preferencias

Paso 2: Preferencias de Ga en Control / OSC / web en druk op Add

Paso 3: Modo de superficie de control Kies bij para OSC (Control de sonido abierto)

Paso 4: nombre del dispositivo Vul je en, vink Recibe en el puerto aan en vul en agua en el procesamiento de la staat Sendport

Paso 5: Kopieer de Host IP die je hier ziet en vul deze in en Processing

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

Paso 5: Behuizing

Raza: 170 mm

Longitud: 90 mm

Hoogte 30 mm

Knoppen: 16 mm (diámetro

Potenciómetros: 3 mm (diámetro)

Sensor de afstand: Breedte 2.9 mm

Longitud 0,8 mm

Material: MDF (3 mm)

Paso 6: Elektronica

Paso 1:

Verbind de ground en furgoneta Arduino de 5 voltios con placa de pruebas

Paso 2:

Pin Verbind A0 met potentio 1

Pin de verbo A1 met potentio 2

El pin A3 de Verbind se encuentra con el sensor de infrarrojos.

El pin de verificación A2 se encontró con el botón adhesivo de niet.

Verbind pin A5 con el botón adhesivo.

Paso 7: Medewerkers

- Mayes El Baba

- Arno Gorissen

- Michiel De Wandelaer