Retro-controller: 7 stappen

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:19

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 een cassette, ons doel was om een controller te maken dat lijkt op een cassette.

Stap 1: Wat Heb Je Nodig?

Componenten

- 2 Knoppen;

- 2 Potmeters;

- 2 weerstanden (1K eland);

- Arduino uno/nano

- Draadjes (zie elektronisch schema)

- Soldeerplaat

- MDF plaat

Gereedschap

- Lasersnijder

- Kniptang

- Striptang

- Soldeerbout (met tin)

Programma's

- Illustrator/indesign (Tekenprogramma)

- Reaper

- Verwerken

- Arduino

Stap 2: Codeverwerking

/**

* Basisschets om Seriële berichten van Arduino te ontvangen * en vertaalt deze naar OSC-berichten voor Reaper * * U moet de GEBRUIKERSPARAMETERS aanpassen * en u moet een bibliotheek installeren: oscP5 * * gemaakt voor werkcollege AV&IT * door annoo bob eddi * okt 2017 * */ ///////////////////// GEBRUIKERSPARAMETERS //////////////////// ////////

/ zorg ervoor dat je dezelfde baudrate gebruikt in je Arduino sketch final int baudRate = 115200;

// Ga op zoek naar het IP-adres in Reaper bij gebruik van OSC // Dit is het adres waar Processing naartoe stuurt en waar Reaper naar luistert. // Zet deze string hier in remoteIP.

//final String remoteIP = "192.168.1.43"; // bijv. "127.0.0.1";

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

// Noteer de sendPort en vul deze in in Reaper. // Dit is de poort waar Processing naartoe stuurt en waar Reaper naar luistert.

final int listenPort = 11000, sendPort = 12000;

// De listenPort hier is om actief te debuggen.

// de portNames zijn hier ook om te debuggen.

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

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

///////////////////// EINDE van GEBRUIKERSPARAMETERS ///////////////////////// ////

importverwerking.serienummer.*; import java.util.*;

importeer oscP5.*; import netP5.*;

OscP5 oscP5; NetAddress myRemoteLocation;

Seriële communicatiepoort; // Het booleaanse bericht van de seriële poortArrived = false;

String inkomend = "", IncomingOSCMessage = "";

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

// Om er zeker van te zijn dat we alleen de parameters (waarden) verzenden die veranderen // worden deze globale variabelen hier vermeld, maar mogen // hier niet worden geïnitialiseerd! HashMap oude Params, nieuwe Params, toSendParams;

// We moeten het bericht splitsen bij elke komma leegte processIncoming () { String resVec = inkomende.split(", "); // we krijgen naam + waardeparen // dus voor elke naam (+2)… try{ for (int i = 0; i< resVec.length; i+=2) { float value = Float.parseFloat(resVec[i+ 1]); // plaats ze in de nieuwe hashtabel newParams.put(resVec, value); } } // als er een fout optreedt, laten we deze bekijken en afsluiten. catch(Uitzondering ex){ println("Uitzonderingsbericht: " + ex); printArray(resVec); Uitgang(); } }

// Om onze berichten te filteren /* We zorgen ervoor dat er alleen een OSC-out bericht is wanneer * het invoerbericht (Serial) verandert * Dat wil zeggen: als we aan de knop draaien/drukken en deze verandert van waarde. * Dus we filteren de binnenkomende waarden die daadwerkelijk veranderen * let op: we zullen springende waarden niet vermijden * zoals afkomstig zijn van bijvoorbeeld versnellingsmeters of afstandssensoren * je zult deze zelf moeten gladstrijken in Arduino */ void filterParams () { toSendParams = new Hash kaart(); for (String key: newParams.keySet()) { // als de sleutel al aanwezig is if (oldParams.containsKey(key)) { // key aanwezig en waarde niet hetzelfde, update dan if (!oldParams.get(key)).equals(newParams.get(key))) { toSendParams.put(key, newParams.get(key)); } } else{ // key is niet aanwezig in oude parameters, dus zet het maar! toSendParams.put(sleutel, newParams.get(sleutel)); } oldParams.put(key, newParams.get(key)); } }

void makeOSC() { for (String key: toSendParams.keySet()) { OscMessage myMessage = new OscMessage("/"+ key); myMessage.add(toSendParams.get(key)); /* stuur het bericht */ oscP5.send(myMessage, myRemoteLocation); } }

void translateMessage() { processIncoming(); filterParams(); maakOSC(); } // Als we willen afdrukken naar het venster void ShowIncoming() { // om het inkomende bericht te zien, zoals ingesteld in de HashMap-tekst ("Incoming from Arduino", 20, 20); int y = 20; for (String key: newParams.keySet()) { y = y+20; tekst(toets, 20, y); text(newParams.get(key), 300, y); } }

void showOsc() { tekst (Inkomend OSCM-bericht, 300, 200); InkomendOSCMessage =""; }

void setup() { size(1000, 800); // Fasegrootte vullen (255); achtergrond(0); oldParams = nieuwe HashMap(); newParams = nieuwe HashMap(); //printArray(Serial.list()); commsPort = nieuw serieel (dit, poortnaam, baudrate);

/* start oscP5, luisteren naar inkomende berichten */ oscP5 = nieuwe OscP5(this, listenPort);

/* myRemoteLocation is een NetAddress. een NetAddress heeft 2 parameters, * een ip-adres en een poortnummer. myRemoteLocation wordt gebruikt als parameter in * oscP5.send() bij het verzenden van osc-pakketten naar een andere computer, apparaat, * toepassing. gebruik zie hieronder. voor testdoeleinden zijn de luisterpoort * en de poort van het externe locatieadres hetzelfde, vandaar dat u * berichten terugstuurt naar deze schets. */ myRemoteLocation = nieuw NetAddress(remoteIP, sendPort); }

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

void serialEvent (Serial commsPort) {// lees een byte van de seriële poort: char inChar = commsPort.readChar (); switch (inChar) { case contactCharacter: commsPort.write (contactCharacter); // vraag om meer println("beginnend…"); pauze; case startChar: inkomend= ""; pauze; case endChar: messageArrived = waar; //println ("einde bericht"); pauze; standaard: inkomend += inChar; pauze; } }

/* inkomende osc-berichten worden doorgestuurd naar de oscEvent-methode. */ void oscEvent(OscMessage theOscMessage) { float value = theOscMessage.get(0).floatValue(); // haal het 1e osc-argument op

IncomingOSCMessage += "\n" + String.format("### heeft een osc-bericht ontvangen: " + " addrpattern: " + theOscMessage.addrPattern() + ": %f", value); println (Inkomend OSCM-bericht); }

Stap 3: Codeer Arduino

/* Deze code is een basisschets om te communiceren met Processing via Serial.

Het is een blauwdruk waarin u uw eigen code kunt opgeven voor uw eigen knoppen, potentiometers of sensoren.

Het heeft een handdruk om ervoor te zorgen dat we contact hebben en het formaat waarin we communiceren is bepaald

Het is belangrijk om het bericht op dezelfde manier op te bouwen, zodat Processing het weet te deconstrueren en correcte OSC-berichten naar onze DAW te sturen

gemaakt voor werkcollege AV&IT okt 2017

code smooothing gemaakt 22 april 2007 door David A. Mellis gewijzigd 9 april 2012 door Tom Igoe

*/

/ baudrate const lange baudRate = 115200;

// tijd om te wachten in ms tussen peilingen naar de pinnen const int loopPauseTime = 200; // milliseconden

// begin- en eindwaarden voor het bericht verzonden op Serial const String startString = "*", endString = "#";

const char contactCharacter = '|';

// const id's const int buttonPin1 = 2; const int knopPin2 = 5; const int numReadings = 5; //tarief van smoothing

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

// andere globale variabelen int buttonState1 = 0; int knopState2 = 0; // variabele voor het lezen van de drukknopstatus float sensorValue1 = 0; vlottersensorWaarde2 = 0; vlottersensor Waarde3 = 0;

// afvlakking van int-metingen [numReadings]; // de metingen van de analoge ingang int readIndex3 = 0; // de index van de huidige meting int total3 = 0; // het lopende totale float-gemiddelde3 = 0; // het gemiddelde

// We hebben deze functie nodig om contact te maken met de Processing sketch // Keep it here void establishmentContact() { while (Serial.available() <= 0) { Serial.print(contactCharacter); // stuur een char en wacht op een reactie… delay(loopPauseTime); } Serieel.lezen(); }

void setup () {// stel de pinModes in voor alle pinnen pinMode (buttonPin1, INPUT); pinMode (knopPin2, INPUT); pinMode (pitchReading, INPUT); pinMode (speedReading, INPUT); pinMode (infraReading, INPUT);

// initialiseer seriële communicatie Serial.begin (baudRate); terwijl (!Serial); // gladstrijken voor (int thisReading = 0; thisReading <numReadings; thisReading++) { readings [thisReading] = 0; }

// wacht op handdruk establishmentContact(); }

void loop () {// poll alle pinnen en wijs de meting toe aan het juiste bereik buttonState1 = digitalRead (buttonPin1); buttonState2 = digitalRead (buttonPin2); sensorValue1 = analogRead (pitchReading); sensorValue2 = analogRead (speedReading); sensorValue3 = analogRead (infraReading);

// toewijzen van de binnenkomende waarden aan noodzakelijke waarden sensorValue1 = map (sensorValue1, 0, 1023, 0, 100.0)/-100.0; sensorValue2 = kaart(sensorValue2, 0, 1023, 0.0, 100)/100.0; sensorValue3 = kaart (sensorValue3, 0, 700, 50, 100);

// afvlakkingssensor: totaal3 = totaal3 - metingen [readIndex3]; // lees van de sensor: lezingen [readIndex3] = sensorValue3; // voeg de meting toe aan het totaal: total3 = total3 + readings [readIndex3]; // ga door naar de volgende positie in de array: readIndex3 = readIndex3 + 1;

// als we aan het einde van de array zijn … if (readIndex3 >= numReadings) { // … wikkel rond naar het begin: readIndex3 = 0; } // bereken het gemiddelde: gemiddelde3 = (total3 / numReadings); // afvlakkingssensor

Serial.print (startString); // start een berichtenreeks // schrijf alle naam-, waardeparen, gescheiden door komma's Serial.print ("potentio1"); Serieel.print(", "); Serial.print(sensorValue1); Serieel.print(", ");

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

Serial.print("infrasensor"); Serieel.print(", "); Seriële.afdruk (gemiddeld 3/100); Serieel.print(", ");

Serial.print("knop 1 in2 wit"); Serieel.print(", "); Serial.print(knopState1); Serieel.print(", "); Serial.print("knop2 in5 geel"); Serieel.print(", "); Serial.print(knopState2);

// schrijf het einde van het bericht Serial.print (endString);

// even wachten..

vertraging (loopPauseTime); }

Stap 4: Reaper

Stap 1: Ga naar boven naar Opties>Voorkeur

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

Stap 3: Kies bij Control surface mode voor OSC (Open Sound Control)

Stap 4: Vul je device name in, vink Recieve on port aan en vul in water in processing bij Sendport staat

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

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

Stap 5: Behuizing

Breedte: 170 mm

lengte: 90 mm

Hoogte 30 mm

Knoppen: 16 mm (diameter)

Potentiometers: 3 mm (diameter)

Afstand sensor: Breedte 2,9 mm

lengte 0,8 mm

Materiaal: MDF (3mm)

Stap 6: Elektronica

Stap 1:

Verbind de grond en 5 volt van Arduino met het breadboard

Stap 2:

Verbind pin A0 met potentio 1

Verbind pin A1 met potentio 2

Verbind pin A3 met infrarood sensor.

Verbind pin A2 met de niet kleverige knop.

Verbind pin A5 met de plakknop.

Stap 7: Medewerkers

- Mayes El Baba

- Arno Gorissen

- Michiel De Wandelaar