Controller retrò: 7 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:04

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.

Passaggio 1: Wat Heb Je Nodig?

componenti

- 2 pulsanti;

- 2 Potenziometri;

- 2 weerstanden (1K alci);

- Arduino uno/nano

- Draadjes (schema elettronico di zie)

- Soldeerplaat

- Pannello in MDF

Utensili

- Taglio laser

- Kniptang

- Spogliarello

- Soldeerbout (met stagno)

programmi

- Illustratore/indesign (Tekenprogramma)

- Mietitore

- In lavorazione

- Arduino

Passaggio 2: elaborazione del codice

/**

* Schizzo di base per ricevere messaggi seriali da Arduino * e tradurli in messaggi OSC per Reaper * * Dovrai adattare i PARAMETRI UTENTE * e dovrai installare una libreria: oscP5 * * realizzato per werkcollege AV&IT * di annoo bob eddi * ott 2017 * */ //////////////////// PARAMETRI UTENTE //////////////////// ////////

/ assicurati di utilizzare la stessa velocità di trasmissione nel tuo schizzo Arduino final int baudRate = 115200;

// Vai e cerca l'indirizzo IP in Reaper quando usi OSC // Questo è l'indirizzo a cui Processing invia e Reaper ascolta. // Inserisci questa stringa in remoteIP, qui.

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

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

// Prendi nota del sendPort e inseriscilo in Reaper. // Questa è la porta a cui Processing invia e Reaper ascolta.

final int listenPort = 11000, sendPort = 12000;

// Il listenPort qui serve per eseguire attivamente il debug.

// anche i portNames sono qui per eseguire il debug.

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

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

///////////////////// FINE dei PARAMETRI UTENTE ///////////////////////// ////

import processing.serial.*; import java.util.*;

importa oscP5.*; importa netP5.*;

OscP5 oscP5; NetAddress myRemoteLocation;

Porta di comunicazione seriale; // La porta seriale booleana messageArrived = false;

Stringa in arrivo = "", IncomingOSCMessage = "";

carattere finale startChar = '*', endChar = '#'; carattere finale contactCharacter = '|';

// Per assicurarci di inviare solo i parametri (valori) che cambiano // queste variabili globali sono qui definite ma // non dovrebbero essere inizializzate qui! HashMap oldParams, newParams, toSendParams;

// Dobbiamo dividere il messaggio ad ogni virgola void processIncoming () { String resVec = incoming.split(", "); // otteniamo le coppie nome + valore // quindi per ogni nome (+2)… try{ for (int i = 0; i< resVec.length; i+=2) { float value = Float.parseFloat(resVec[i+ 1]); // li inserisco nella nuova Hashtable newParams.put(resVec, value); } } // se si verifica un errore, prendiamolo visualizza ed esci. catch(Eccezione ex){ println("Messaggio eccezione: " + ex); printArray(resVec); Uscita(); } }

// Per filtrare i nostri messaggi /* Ci assicuriamo che ci sia solo un messaggio OSC-out quando * cambia il messaggio di input (Serial) * Cioè: se giriamo/prememo il pulsante e cambia valore. * Quindi filtriamo i valori in entrata che effettivamente cambiano * nota: non eviteremo di saltare i valori * come provengono ad esempio da accelerometri o sensori di distanza * dovrai livellarli tu stesso in Arduino */ void filterParams () { toSendParams = new HashMap(); for (String key: newParams.keySet()) { // se la chiave è già presente if (oldParams.containsKey(key)) { // chiave presente e valore diverso, quindi aggiorna if (!oldParams.get(key).equals(newParams.get(key))) { toSendParams.put(key, newParams.get(key)); } } else{ // la chiave non è presente nei vecchi parametri, quindi mettila! 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)); /* invia il messaggio */ oscP5.send(myMessage, myRemoteLocation); } }

void translateMessage() { processIncoming(); filterParams(); makeOSC(); } // Quando vogliamo stampare sulla finestra void ShowIncoming() { // per vedere il messaggio in arrivo, come impostato nel testo HashMap("Incoming from Arduino", 20, 20); int y = 20; for (String key: newParams.keySet()) { y = y+20; testo(chiave, 20, y); text(newParams.get(key), 300, y); } }

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

void setup() { size(1000, 800); // Dimensioni dello stage fill(255); sfondo(0); oldParams = new HashMap(); newParams = new HashMap(); //printArray(Serial.list()); comsPort = new Serial(this, portName, baudRate);

/* avvia oscP5, in ascolto dei messaggi in arrivo */ oscP5 = new OscP5(this, listenPort);

/* myRemoteLocation è un NetAddress. un NetAddress accetta 2 parametri, * un indirizzo IP e un numero di porta. myRemoteLocation viene utilizzato come parametro in * oscP5.send() quando si inviano pacchetti osc a un altro computer, dispositivo, * applicazione. utilizzo vedi sotto. a scopo di test, la porta di ascolto * e la porta dell'indirizzo della posizione remota sono le stesse, quindi * invierai messaggi a questo sketch. */ myRemoteLocation = new NetAddress(remoteIP, sendPort); }

void draw() { if (messageArrived) { background(0); translateMessage(); MostraIn arrivo(); messaggioArrivato= falso; } showOsc(); }

void serialEvent(Serial comsPort) { // legge un byte dalla porta seriale: char inChar = comsPort.readChar(); switch (inChar) { case contactCharacter: commsPort.write(contactCharacter); // chiedi di più println("inizio…"); rottura; case startChar: incoming= ""; rottura; case endChar: messageArrived = true; //println("fine del messaggio"); rottura; default: in entrata += inChar; rottura; } }

/* i messaggi osc in arrivo vengono inoltrati al metodo oscEvent. */ void oscEvent(OscMessage theOscMessage) { float value = theOscMessage.get(0).floatValue(); // ottiene il primo argomento osc

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

Passaggio 3: codifica Arduino

/* Questo codice è uno schizzo di base per comunicare con Processing tramite Serial.

È un progetto in cui puoi inserire il tuo codice specifico per i tuoi pulsanti, potenziometri o sensori.

Ha una stretta di mano per assicurarci di avere un contatto e il formato in cui stiamo comunicando è deciso

È importante costruire il messaggio allo stesso modo, in modo che Processing sappia come decostruirlo e inviare messaggi OSC corretti alla nostra DAW

realizzato per il werkcollege AV&IT ottobre 2017

smussamento del codice creato il 22 aprile 2007 da David A. Mellis modificato il 9 aprile 2012 da Tom Igoe

*/

/ baud rate const long baudRate = 115200;

// tempo di attesa in ms tra i poll ai pin const int loopPauseTime = 200; // milli secondi

// valori di inizio e fine del messaggio inviato su Serial const String startString = "*", endString = "#";

const char contactCharacter = '|';

// id pin const int buttonPin1 = 2; const int buttonPin2 = 5; const int numLetture = 5; //tassa il furgone levigante

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

// altre variabili globali int buttonState1 = 0; int buttonState2 = 0; // variabile per la lettura dello stato del pulsante float sensorValue1 = 0; valore sensore galleggiante2 = 0; sensore galleggianteValore3 = 0;

//livellamento letture int[numReadings]; // le letture dall'ingresso analogico int readIndex3 = 0; // l'indice della lettura corrente int total3 = 0; // la media mobile totale in esecuzione3 = 0; // la media

// Abbiamo bisogno di questa funzione per stabilire un contatto con lo schizzo Processing // Mantienilo qui void stabilireContact() { while (Serial.available() <= 0) { Serial.print(contactCharacter); // invia un carattere e aspetta una risposta… delay(loopPauseTime); } Serial.read(); }

void setup() { // imposta i pinModes per tutti i pin pinMode(buttonPin1, INPUT); pinMode(pulsantePin2, INGRESSO); pinMode(pitchReading, INPUT); pinMode(speedReading, INPUT); pinMode(infraLettura, INPUT);

// inizializza le comunicazioni seriali Serial.begin(baudRate); mentre (!Seriale); //smoothing for (int thisReading = 0; thisReading < numReadings; thisReading++) { readings[thisReading] = 0; }

// attendi la stretta di mano stabilireContact(); }

void loop() { // interroga tutti i pin e mappa la lettura nell'intervallo appropriato buttonState1 = digitalRead(buttonPin1); buttonState2 = digitalRead(buttonPin2); sensorValue1 = analogRead (pitchReading); sensorValue2 = analogRead (speedReading); sensorValue3 = analogRead (infraReading);

//mappa i valori in ingresso ai valori necessari sensorValue1 = map(sensorValue1, 0, 1023, 0, 100.0)/-100.0; SensorValue2 = map(sensorValue2, 0, 1023, 0.0, 100)/100.0; SensorValue3 = map(sensorValue3, 0, 700, 50, 100);

// sensore di livellamento: total3 = total3 - readings[readIndex3]; // legge dal sensore: readings[readIndex3] = sensorValue3; // somma la lettura al totale: total3 = total3 + readings[readIndex3]; // avanza alla posizione successiva nell'array: readIndex3 = readIndex3 + 1;

// se siamo alla fine dell'array… if (readIndex3 >= numReadings) { // …torna all'inizio: readIndex3 = 0; } // calcola la media: media3 = (total3 / numReadings); // sensore di levigatura

Serial.print(startString); // avvia una sequenza di messaggi // scrivi tutti i nomi, le coppie di valori, separati da virgole Serial.print("potentio1"); Serial.print(", "); Serial.print(sensorValue1); Serial.print(", ");

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

Serial.print("infra-sensore"); Serial.print(", "); Serial.print(media3/100); Serial.print(", ");

Serial.print("knop 1 in2 wit"); Serial.print(", "); Serial.print(Statopulsante1); Serial.print(", "); Serial.print("knop2 in5 geel"); Serial.print(", "); Serial.print(Statopulsante2);

// scrive la fine del messaggio Serial.print(endString);

// aspettare per un po..

delay(loopPauseTime); }

Passaggio 4: Mietitore

Passo 1: Vai a vedere Opzioni>Preferenze

Fase 2: Ga nelle preferenze accanto a Control/OSC/web e druk op Add

Fase 3: Kies bij Modalità superficie di controllo per OSC (Open Sound Control)

Passo 4: Vul je nome del dispositivo in, vink Ricevi sulla porta aan en vul in acqua in elaborazione bij Sendport staat

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

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

Passaggio 5: Behuizing

Razza: 170 mm

Lunghezza: 90 mm

Hoogte 30 mm

Manopola: 16 mm (diametro

Potenziometri: 3 mm (diametro)

Sensore di poppa: Breedte 2,9 mm

Lunghezza 0,8 mm

Materiale: MDF (3 mm)

Passaggio 6: elettronica

Fase 1:

Verbind de ground en 5 volt van Arduino con la breadboard

Fase 2:

Verbind pin A0 con potenziometro 1

Verbind pin A1 con potenziometro 2

Verbind pin A3 con sensore a infrarossi.

Spilla Verbind A2 con bottone appiccicoso.

Spilla Verbind A5 con bottone adesivo.

Passaggio 7: Medewerkers

- Mayes El Baba

- Arno Gorissen

- Michiel De Wandelaer