Retro-Controller - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:21

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, can terugspoelen en nog meer.

Ons kwam van van een Kassette, Ons Doel war om een Controller te maken dat lijkt op een Kassette.

Schritt 1: Wat Heb Je Nodig?

Komponenten

- 2 Tasten;

- 2 Potentiometer;

- 2 Weerstanden (1K Elch);

- Arduino uno/nano

- Draadjes (zie elektronisches Schema)

- Soldeerplaat

- MDF-Platte

Werkzeuge

- Laserschneider

- Kniptang

- Striptang

- Soldeerbout (met Zinn)

Programmas

- Illustrator/Indesign (Tekenprogramma)

- Sensenmann

- Wird bearbeitet

- Arduino

Schritt 2: Codeverarbeitung

/**

* Grundskizze um serielle Nachrichten von Arduino zu empfangen * und übersetzt diese in OSC-Nachrichten für Reaper * * Sie müssen die USER PARAMETER anpassen * und Sie müssen eine Bibliothek installieren: oscP5 * * made for werkcollege AV&IT * von annoo bob eddi * Okt 2017 * */ ///////////////////// BENUTZERPARAMETER //////////////////// ////////

/ stellen Sie sicher, dass Sie die gleiche Baudrate in Ihrer Arduino-Skizze verwenden final int baudRate = 115200;

// Suchen Sie in Reaper nach der IP-Adresse, wenn Sie OSC verwenden. // Dies ist die Adresse, an die Processing sendet und auf die Reaper hört. // Diesen String hier in remoteIP einfügen.

//letzter String remoteIP = "192.168.1.43"; //z. B. "127.0.0.1";

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

// Notieren Sie sich den sendPort und tragen Sie diesen in Reaper ein. // Dies ist der Port, an den Processing sendet und auf den Reaper lauscht.

final int listenPort = 11000, sendPort = 12000;

// Der listenPort hier dient zum aktiven Debuggen.

// die portNames sind auch zum debuggen da.

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

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

///////////////////// ENDE BENUTZERPARAMETER ///////////////////////// ////

Importabwicklung.seriell.*; java.util.* importieren;

oscP5.* importieren; importieren netP5.*;

OscP5 oscP5; NetAddress myRemoteLocation;

Serieller Kommunikationsanschluss; // Der Boolesche Port der seriellen Schnittstelle messageArrived = false;

String eingehend = "", IncomingOSCMessage = "";

finales Zeichen startChar = '*', endChar = '#'; letztes Zeichen contactCharacter = '|';

// Um sicherzustellen, dass nur die Parameter (Werte) gesendet werden, die sich // ändern, werden diese globalen Variablen hier gelöscht, sollten aber // hier nicht initialisiert werden! HashMap oldParams, newParams, toSendParams;

// Wir müssen die Nachricht bei jedem Komma aufteilen void processIncoming () { String resVec = eingehend.split(", "); // wir erhalten Name + Wert-Paare // also für jeden Namen (+2)… try{ for (int i = 0; i< resVec.length; i+=2) { float value = Float.parseFloat(resVec[i+ 1]); // lege sie in die neue Hashtable newParams.put(resVec, value); } } // Wenn ein Fehler auftritt, fangen wir ihn ab und beenden ihn. catch(Ausnahme ex){ println("Ausnahmemeldung: " + ex); printArray(resVec); Ausfahrt(); } }

// Um unsere Nachrichten zu filtern /* Wir stellen sicher, dass es nur eine OSC-out-Nachricht gibt, wenn * sich die Eingabenachricht (Seriell) ändert * Das heißt: wenn wir den Knopf drehen/drücken und der Wert ändert. * Also filtern wir die eingehenden Werte heraus, die sich tatsächlich ändern * Hinweis: Wir werden nicht springende Werte vermeiden * wie sie zB von Beschleunigungsmessern oder Distanzsensoren kommen * diese müssen Sie in Arduino selbst glätten */ void filterParams () { toSendParams = new HashMap(); for (String key: newParams.keySet()) { // wenn der Schlüssel bereits vorhanden ist if (oldParams.containsKey(key)) { // Schlüssel vorhanden und Wert nicht gleich, dann update if (!oldParams.get(key).equals(newParams.get(key))) { toSendParams.put(key, newParams.get(key)); } } else{ // Schlüssel ist in alten Parametern nicht vorhanden, also sag es! 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)); /* Nachricht senden */ oscP5.send(myMessage, myRemoteLocation); } }

void translateMessage() { processIncoming(); filterParams(); makeOSC(); } // Wenn wir in das Fenster drucken möchten void ShowIncoming () { // um eingehende Nachrichten zu sehen, wie in der HashMap-Text festgelegt ("Incoming from Arduino", 20, 20); int y = 20; for (String key: newParams.keySet()) { y = y+20; text(Taste, 20, y); text(newParams.get(key), 300, y); } }

Void showOsc () { Text (IncomingOSCMessage, 300, 200); IncomingOSCMessage =""; }

Void setup () { Größe (1000, 800); // Bühnengröße füllen (255); Hintergrund(0); oldParams = new HashMap(); newParams = new HashMap(); //printArray(Serial.list()); commsPort = new Serial(this, portName, baudRate);

/* oscP5 starten, auf eingehende Nachrichten warten */ oscP5 = new OscP5(this, listenPort);

/* myRemoteLocation ist eine NetAddress. eine NetAddress benötigt 2 Parameter, * eine IP-Adresse und eine Portnummer. myRemoteLocation wird als Parameter in * oscP5.send() verwendet, wenn osc-Pakete an einen anderen Computer, ein Gerät oder eine Anwendung * gesendet werden. Nutzung siehe unten. zu Testzwecken sind der Listening-Port * und der Port der Remote-Standort-Adresse identisch, daher werden Sie * Nachrichten an diesen Sketch zurücksenden. */ myRemoteLocation = new NetAddress(remoteIP, sendPort); }

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

void serialEvent(Serial commsPort) {// ein Byte vom seriellen Port lesen: char inChar = commsPort.readChar(); switch (inChar) { case contactCharacter: commsPort.write (contactCharacter); // nach mehr fragen println("beginnend…"); brechen; case startChar: eingehend= ""; brechen; case endChar: messageArrived = true; //println("Ende der Nachricht"); brechen; Standard: eingehend += inChar; brechen; } }

/* eingehende osc-Nachrichten werden an die oscEvent-Methode weitergeleitet. */ void oscEvent(OscMessage theOscMessage) { float value = theOscMessage.get(0).floatValue(); // Hole das erste osc-Argument

IncomingOSCMessage += "\n" + String.format("### hat eine OSC-Nachricht erhalten: " + " addrpattern: " + theOscMessage.addrPattern() + ": %f", value); println(IncomingOSCMessage); }

Schritt 3: Arduino codieren

/* Dieser Code ist eine grundlegende Skizze für die Kommunikation mit Processing über Serial.

Es ist eine Blaupause, in die Sie Ihren eigenen Code für Ihre eigenen Tasten, Potentiometer oder Sensoren eingeben können.

Es hat einen Handschlag, um sicherzustellen, dass wir Kontakt haben und das Format, in dem wir kommunizieren, wird festgelegt

Es ist wichtig, die Nachricht auf die gleiche Weise zu erstellen, damit Processing weiß, wie sie sie dekonstruieren und korrekte OSC-Nachrichten an unsere DAW senden kann

Made for werkcollege AV&IT Okt 2017

Code-Smooothing Erstellt am 22. April 2007 von David A. Mellis geändert am 9. April 2012 von Tom Igoe

*/

/ Baudrate const long baudRate = 115200;

// Wartezeit in ms zwischen den Abfragen an die Pins const int loopPauseTime = 200; // Millisekunden

// Start- und Endwerte für die gesendete Nachricht Serial const String startString = "*", endString = "#";

const char contactCharacter = '|';

// const int buttonPin1 = 2; const int buttonPin2 = 5; const int numReadings = 5; //Van Glättung bewerten

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

// andere globale Variablen int buttonState1 = 0; int buttonState2 = 0; // Variable zum Lesen des Tasterstatus float sensorValue1 = 0; SchwimmersensorWert2 = 0; SchwimmersensorWert3 = 0;

// Glättung von Int-Messwerten [numReadings]; // die Messwerte vom analogen Eingang int readIndex3 = 0; // der Index des aktuellen Messwerts int total3 = 0; // die laufende Summe float Average3 = 0; // der Durchschnitt

// Wir brauchen diese Funktion, um den Kontakt mit der Verarbeitungsskizze herzustellen // Hier halten void EstablishContact () { while (Serial.available () <= 0) { Serial.print (contactCharacter); // ein Zeichen senden und auf eine Antwort warten… delay(loopPauseTime); } Serial.read(); }

Void setup () {// setze die PinModes für alle Pins PinMode (buttonPin1, INPUT); pinMode (buttonPin2, INPUT); pinMode (pitchReading, INPUT); pinMode (speedReading, INPUT); pinMode (InfraReading, EINGANG);

// serielle Kommunikation initialisieren Serial.begin (baudRate); while (!Seriell); // Glätten für (int thisReading = 0; thisReading < numReadings; thisReading++) { Lesungen [thisReading] = 0; }

// Warte auf Handshake EstablishContact(); }

Void loop () {// alle Pins abfragen und den Messwert dem entsprechenden Bereich zuordnen buttonState1 = digitalRead (buttonPin1); buttonState2 = digitalRead (buttonPin2); sensorValue1 = analogRead (pitchReading); sensorValue2 = analogRead (speedReading); sensorValue3 = analogRead (infraReading);

// Zuordnen der eingehenden Werte zu notwendigen Werten 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);

// Glättungssensor: total3 = total3 - Messwerte [readIndex3]; // vom Sensor lesen: Lesungen [readIndex3] = sensorValue3; // den Messwert zur Summe hinzufügen: total3 = total3 + Readings[readIndex3]; // Weiter zur nächsten Position im Array: readIndex3 = readIndex3 + 1;

// wenn wir am Ende des Arrays sind… if (readIndex3 >= numReadings) { // …umbruch zum Anfang: readIndex3 = 0; } // den Durchschnitt berechnen: Average3 = (total3 / numReadings); // Glättungssensor

Serial.print (startString); // eine Nachrichtensequenz starten // alle Namen, Wertepaare, durch Kommas getrennt angeben Serial.print("potentio1"); Serial.print (", "); Serial.print (sensorValue1); Serial.print (", ");

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

Serial.print ("Infrasensor"); Serial.print (", "); Serial.print (durchschnittlich 3/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);

// Schreiben Sie das Ende der Nachricht Serial.print (endString);

// warten Sie eine Weile..

Verzögerung (SchleifePauseTime); }

Schritt 4: Schnitter

Schritt 1: Ga bovenaan naar Optionen>Einstellungen

Schritt 2: Verstärkung der Einstellungen für Control/OSC/Web und Druk op Add

Schritt 3: Kies bij Oberflächenmodus für OSC (Open Sound Control)

Schritt 4: Vul je Gerätename in, vink Empfangen am Port aan en vul in water in processing bij Sendport staat

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

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

Schritt 5: Behuizing

Rasse: 170 mm

Länge: 90 mm

Hoogte 30 mm

Knoppen: 16 mm (Durchmesser

Potentiometer: 3 mm (Durchmesser)

Afstand-Sensor: Breedte 2,9 mm

Länge 0,8 mm

Material: MDF (3mm)

Schritt 6: Elektronik

Schritt 1:

Verbind de ground en 5 Volt van Arduino mit dem Steckbrett

Schritt 2:

Verbind Pin A0 mit Potentio 1

Verbind Pin A1 mit Potentio 2

Verbinden Sie Pin A3 mit Infrarotsensor.

Binden Sie die Anstecknadel A2 mit dem nicht klebrigen Knopf.

Binden Sie die Anstecknadel A5 mit dem Klebeknopf.

Schritt 7: Medewerker

- Mayes El Baba

- Arno Gorissen

- Michiel De Wandelaer