Contrôleur rétro : 7 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:09

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 était om een controller te maken dat lijkt open een cassette.

Étape 1: Wat Heb Je Nodig ?

Composants

- 2 boutons;

- 2 Potentiomètres;

- 2 weerstanden (élan 1K);

- Arduino uno/nano

- Draadjes (schéma zie elektronisch)

- Soldeerplaat

- Plat en MDF

Outils

- Découpeur laser

- Kniptang

- Strip-tange

- Soldeerbout (étain rencontré)

Programmes

- Illustrateur/indesign (Tekenprogramma)

- Moissonneuse

- Traitement

-Arduino

Étape 2: Traitement du code

/**

* Esquisse de base pour recevoir les messages série d'Arduino * et les traduire en messages OSC pour Reaper * * Vous devrez adapter les PARAMÈTRES UTILISATEUR * et vous devrez installer une bibliothèque: oscP5 * * conçu pour werkcollege AV&IT * par annoo bob eddi * oct 2017 * */ //////////////////// PARAMETRES UTILISATEUR /////////////////// ////////

/ assurez-vous d'utiliser le même débit en bauds dans votre croquis Arduino final int baudRate = 115200;

// Allez chercher l'adresse IP dans Reaper lorsque vous utilisez OSC // Il s'agit de l'adresse à laquelle Processing envoie et que Reaper écoute. // Mettez cette chaîne dans remoteIP, ici.

//chaîne finale remoteIP = "192.168.1.43"; //par exemple. "127.0.0.1";

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

// Prenez note du sendPort et remplissez-le dans Reaper. // Il s'agit du port auquel Processing envoie et que Reaper écoute.

int final listenPort = 11000, sendPort = 12000;

// Le listenPort ici est à déboguer activement.

// les portNames sont également là pour déboguer.

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

// chaîne finale nom_port = "COM6"; // "/dev/ttyUSB0";

//////////////////// FIN DES PARAMETRES UTILISATEUR //////////////////////// ////

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

importer oscP5.*; importer netP5.*;

OscP5 oscP5; NetAddress myRemoteLocation;

Port de communication série; // Le booléen du port série messageArrived = false;

Chaîne entrant = "", IncomingOSCMessage = "";

caractère final startChar = '*', endChar = '#'; caractère final contactCharacter = '|';

// Pour s'assurer que nous n'envoyons que les paramètres (valeurs) qui changent // ces variables globales sont supprimées ici mais ne doivent // pas être initialisées ici ! HashMap oldParams, newParams, toSendParams;

// Nous devons diviser le message à chaque virgule vide processIncoming () { String resVec = entrant.split(", "); // on obtient des paires nom + valeur // donc pour chaque nom (+2)… try{ for (int i = 0; i< resVec.length; i+=2) { float value = Float.parseFloat(resVec[i+ 1]); // les place dans la nouvelle table de hachage newParams.put(resVec, value); } } // si une erreur se produit, attrapons-la et sortons. catch(Exception ex){ println("Message d'exception: " + ex); printArray(resVec); sortir(); } }

// Pour filtrer nos messages /* Nous nous assurons qu'il n'y a qu'un message de sortie OSC lorsque * le message d'entrée (Série) change * C'est-à-dire: si nous tournons/appuyons sur le bouton et qu'il change de valeur. * Nous filtrons donc les valeurs entrantes qui changent réellement * note: nous n'éviterons pas de sauter des valeurs * comme provenant par exemple d'accéléromètres ou de capteurs de distance * vous devrez les lisser vous-même dans Arduino */ void filterParams () { toSendParams = new HashMap(); for (String key: newParams.keySet()) { // si la clé est déjà présente if (oldParams.containsKey(key)) { // clé présente et valeur différente, puis mettez à jour si (!oldParams.get(key).equals(newParams.get(key))) { toSendParams.put(key, newParams.get(key)); } } else{ // la clé n'est pas présente dans les anciens paramètres, alors mettez-la ! toSendParams.put(clé, newParams.get(clé)); } oldParams.put(clé, newParams.get(clé)); } }

void makeOSC() { for (String key: toSendParams.keySet()) { OscMessage myMessage = new OscMessage("/"+ key); monMessage.add(toSendParams.get(clé)); /* envoyer le message */ oscP5.send(myMessage, myRemoteLocation); } }

void translateMessage() { processIncoming(); filterParams(); makeOSC(); } // Lorsque nous voulons imprimer dans la fenêtre void ShowIncoming() { // pour voir le message entrant, tel que défini dans le texte HashMap ("Incoming from Arduino", 20, 20); entier y = 20; for (String key: newParams.keySet()) { y = y+20; text(clé, 20, y); text(newParams.get(clé), 300, y); } }

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

void setup() { size(1000, 800); // Remplissage de la taille de la scène (255); arrière-plan(0); oldParams = new HashMap(); newParams = new HashMap(); //printArray(Serial.list()); commsPort = new Serial(this, portName, baudRate);

/* démarrer oscP5, en écoutant les messages entrants */ oscP5 = new OscP5(this, listenPort);

/* myRemoteLocation est une NetAddress. une NetAddress prend 2 paramètres, * une adresse IP et un numéro de port. myRemoteLocation est utilisé comme paramètre dans * oscP5.send() lors de l'envoi de paquets osc à un autre ordinateur, périphérique, * application. utilisation voir ci-dessous. à des fins de test, le port d'écoute * et le port de l'adresse de l'emplacement distant sont les mêmes, vous devrez donc * renvoyer des messages à cette esquisse. */ myRemoteLocation = new NetAddress(remoteIP, sendPort); }

void draw() { if (messageArrived) { background(0); translateMessage(); AfficherEntrant(); messageArrivé= false; } showOsc(); }

void serialEvent(Serial commsPort) { // lit un octet du port série: char inChar = commsPort.readChar(); switch (inChar) { case contactCharacter: commsPort.write(contactCharacter); // demande plus println("start…"); Pause; case startChar: entrant=""; Pause; case endChar: messageArrived = true; //println("fin du message"); Pause; par défaut: entrant += inChar; Pause; } }

/* les messages osc entrants sont transmis à la méthode oscEvent. */ void oscEvent(OscMessage theOscMessage) { float value = theOscMessage.get(0).floatValue(); // obtient le 1er argument osc

IncomingOSCMessage += "\n" + String.format("### a reçu un message osc: " + " addrpattern: " + theOscMessage.addrPattern() + ": %f", valeur); println(IncomingOSCMessage); }

Étape 3: Coder Arduino

/* Ce code est une esquisse de base pour communiquer avec Processing via Serial.

C'est un plan dans lequel vous pouvez mettre votre propre code spécifié pour vos propres boutons, potentiomètres ou capteurs.

Il a une poignée de main pour s'assurer que nous avons le contact et le format dans lequel nous communiquons est décidé

Il est important de construire le message de la même manière, afin que Processing sache comment le déconstruire et envoyer des messages OSC corrects à notre DAW

fait pour werkcollege AV&IT oct 2017

lissage de code créé le 22 avril 2007 par David A. Mellis modifié le 9 avril 2012 par Tom Igoe

*/

/ débit en bauds const long baudRate = 115200;

// temps d'attente en ms entre les sondages jusqu'aux broches const int loopPauseTime = 200; // millisecondes

// valeurs de début et de fin du message envoyé sur Serial const String startString = "*", endString = "#";

const char contactCharacter = '|';

// ID de la broche const int buttonPin1 = 2; const int boutonPin2 = 5; const int numLectures = 5; //noter le lissage du van

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

// autres variables globales int buttonState1 = 0; int buttonState2 = 0; // variable de lecture de l'état du bouton poussoir float sensorValue1 = 0; float sensorValue2 = 0; float sensorValue3 = 0;

//lissage des lectures int[numReadings]; // les lectures de l'entrée analogique int readIndex3 = 0; // l'index de la lecture courante int total3 = 0; // la moyenne flottante totale courante3 = 0; // la moyenne

// Nous avons besoin de cette fonction pour établir le contact avec l'esquisse de traitement // Gardez-le ici void établirContact() { while (Serial.available() <= 0) { Serial.print(contactCharacter); // envoie un caractère et attend une réponse… delay(loopPauseTime); } Serial.read(); }

void setup() { // définit les pinModes pour toutes les broches pinMode(buttonPin1, INPUT); pinMode(boutonPin2, INPUT); pinMode(PitchReading, INPUT); pinMode(speedReading, INPUT); pinMode(infraLecture, INPUT);

// initialise les communications série Serial.begin(baudRate); tandis que (!Série); //lissage pour (int thisReading = 0; thisReading < numReadings; thisReading++) { lectures[thisReading] = 0; }

// attend l'établissement de la poignée de mainestablishContact(); }

void loop() { // interroge toutes les broches et mappe la lecture à la plage appropriée buttonState1 = digitalRead(buttonPin1); buttonState2 = digitalRead(buttonPin2); sensorValue1 = analogRead (pitchReading); sensorValue2 = analogRead (speedReading); sensorValue3 = analogRead (infraReading);

// mappage des valeurs entrantes aux valeurs nécessaires 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);

// capteur de lissage: total3 = total3 - lectures[readIndex3]; // lecture depuis le capteur: lectures[readIndex3] = sensorValue3; // ajoute la lecture au total: total3 = total3 + lectures[readIndex3]; // avance à la position suivante dans le tableau: readIndex3 = readIndex3 + 1;

// si nous sommes à la fin du tableau… if (readIndex3 >= numReadings) { // …revenir au début: readIndex3 = 0; } // calcul de la moyenne: average3 = (total3 / numReadings); // capteur de lissage

Serial.print(startString); // démarre une séquence de messages // écris tous les noms, paires de valeurs, séparés par des virgules Serial.print("potentio1"); Serial.print(", "); Serial.print(sensorValue1); Serial.print(", ");

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

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

// écrit la fin du message Serial.print(endString);

// attendre un moment..

delay(loopPauseTime); }

Étape 4: Faucheur

Étape 1: Ga bovenaan naar Options>Préférences

Étape 2: Ga in prefrences naar Control/OSC/web en druk op Ajouter

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

Étape 4: Vul je nom de l'appareil dans, vink Recieve on port aan en vul in water in processing bij Sendport staat

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

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

Étape 5: Behuizing

Taille: 170 mm

Longueur: 90 mm

Hoogte 30 mm

Knoppen: 16 mm (diamètre

Potentiomètres: 3 mm (diamètre)

Capteur d'appui: Breedte 2,9 mm

Longueur 0,8 mm

Matériel: MDF (3mm)

Étape 6: Électronique

Étape 1:

Verbind de ground en 5 volt van Arduino met het breadboard

Étape 2:

Verbind broche A0 rencontré potentio 1

Verbind broche A1 rencontré potentio 2

La broche Verbind A3 a rencontré le capteur infrarouge.

Verbind pin A2 met de niet bouton collant.

Verbind pin A5 avec bouton collant.

Étape 7: Medewerkers

- Mayes El Baba

- Arno Gorissen

- Michiel De Wandelaer