Retro -kontroleerder: 7 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:27

Ons is eerste jaar studente uit die opleiding Multimedia & Communicatietechnologie (Multec) aan die Erasmushogeschool Brussel.

Ons het 'n musiekbeheerder gemaak wat musiek kan begin/stop, maar kan ook terugkeer en meer terugkeer.

Ons idee het van 'n kasset gekom, ons doel was om 'n beheerder te maak wat op 'n kasset lyk.

Stap 1: Wat Heb Je Nodig?

Komponente

- 2 knoppies;

- 2 Potentio meter;

- 2 weerstanden (1K elk);

- Arduino uno/nano

- Draadjes (sien elektroniese skema)

- Soldeerplaat

- MDF plaat

Gereedskap

- Lasersnyer

- Kniptang

- Striptang

- Soldeerbout (met blik)

Programma's

- Illustrator/indesign (tekenprogram)

- Maaier

- Verwerking

- Arduino

Stap 2: Kodeverwerking

/**

* Basiese skets om seriële boodskappe van Arduino te ontvang * en dit na OSC-boodskappe vir Reaper te vertaal * * U moet die GEBRUIKERSPARAMETERS aanpas * en u moet 'n biblioteek installeer: oscP5 * * gemaak vir werkcollege AV&IT * deur annoo bob eddi * okt 2017 * */////////////////////// USER PARAMETERS ////////////////////// ////////

/ maak seker dat u dieselfde baud -tempo gebruik in u Arduino -skets finale int baudRate = 115200;

// Gaan soek die IP-adres in Reaper wanneer u OSC gebruik // Dit is die adres waarna Verwerking stuur en waarna Reaper luister. // Plaas hierdie string hier in remoteIP.

// finale string remoteIP = "192.168.1.43"; // bv. "127.0.0.1";

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

// Let op die sendPort en vul dit in Reaper in. // Dit is die poort waarna Verwerking stuur en waarna Reaper luister.

finale int listenPort = 11000, sendPort = 12000;

// Die luisterpoort hier is om aktief te ontfout.

// die portname is ook hier om te ontfout.

final String portName = "vul hier die poortnaam in Arduino gevind";

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

/////////////////////// EINDE VAN GEBRUIKERSPARAMETERS //////////////////////// ////

invoerverwerking.reeks.*; invoer java.util.*;

invoer oscP5.*; voer netP5 in.*;

OscP5 oscP5; NetAddress myRemoteLocation;

Serial commsPort; // Die booleaanse boodskap van die seriële poortArrived = false;

String inkomend = "", IncomingOSCMessage = "";

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

// Om seker te maak ons stuur slegs die parameters (waardes) wat verander // hierdie globale veranderlikes word hier verwyder, maar moet // nie hier geïnisialiseer word nie! HashMap oldParams, newParams, toSendParams;

// Ons moet die boodskap by elke komma leegte verdeel processIncoming () {String resVec = incoming.split (","); // ons kry naam+waarde pare // so vir elke naam (+2) … probeer {for (int i = 0; i <resVec.length; i+= 2) {float value = Float.parseFloat (resVec [i+ 1]); // plaas dit in die nuwe Hashtable newParams.put (resVec , waarde); }}} // as 'n fout voorkom, laat ons dit vertoon en verlaat. catch (Exception ex) {println ("Exception Message:" + ex); printArray (resVec); uitgang (); }}

// Om ons boodskappe te filter/ * Ons sorg dat daar slegs 'n OSC-out-boodskap is wanneer * die invoerboodskap (Serial) verander * Dit wil sê: as ons die knoppie draai/druk en dit waarde verander. * Dus filter ons die inkomende waardes wat eintlik verander * let op: ons sal nie springwaardes vermy nie * soos afkomstig van versnellingsmeters of afstandsensors * u moet dit self glad maak in Arduino */ void filterParams () {toSendParams = new HashMap (); vir (String key: newParams.keySet ()) {// as die sleutel reeds teenwoordig is as (oldParams.containsKey (key)) {// key present en waarde nie dieselfde is nie, werk dan op as (! oldParams.get (key).gelyk (newParams.get (sleutel))) {toSendParams.put (sleutel, newParams.get (sleutel)); }} anders {// sleutel is nie in ou params beskikbaar nie, so stel dit! toSendParams.put (sleutel, newParams.get (sleutel)); } oldParams.put (sleutel, newParams.get (sleutel)); }}

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

void translateMessage () {processIncoming (); filterParams (); makeOSC (); } // Wanneer ons na die venster wil afdruk, leegmaak ShowIncoming () {// om inkomende boodskap te sien, soos gestel in die HashMap -teks ("Inkomend uit Arduino", 20, 20); int y = 20; vir (String sleutel: newParams.keySet ()) {y = y+20; teks (sleutel, 20, y); teks (newParams.get (sleutel), 300, y); }}

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

ongeldige opstelling () {grootte (1000, 800); // Stadiumgrootte vul (255); agtergrond (0); oldParams = nuwe HashMap (); newParams = nuwe HashMap (); // printArray (Serial.list ()); commsPort = nuwe reeks (hierdie, poortnaam, baudRate);

/ * begin oscP5, luister na inkomende boodskappe */ oscP5 = nuwe OscP5 (hierdie, luisterPort);

/* myRemoteLocation is 'n NetAddress. 'n NetAddress neem 2 parameters, * 'n ip -adres en 'n poortnommer. myRemoteLocation word gebruik as parameter in * oscP5.send () wanneer osc -pakkies na 'n ander rekenaar, toestel, * toepassing gestuur word. gebruik sien hieronder. Vir toetsdoeleindes is die luisterpoort * en die poort van die afgeleë adres dieselfde, daarom stuur u * boodskappe terug na hierdie skets. */ myRemoteLocation = nuwe NetAddress (remoteIP, sendPort); }

leegte teken () {as (boodskap aangekom) {agtergrond (0); translateMessage (); ShowIncoming (); messageArrived = vals; } showOsc (); }

void serialEvent (Serial commsPort) {// lees 'n greep uit die seriële poort: char inChar = commsPort.readChar (); switch (inChar) {case contactCharacter: commsPort.write (contactCharacter); // vra vir meer druk ("begin …"); breek; case startChar: inkomend = ""; breek; case endChar: messageArrived = true; // println ("einde van boodskap"); breek; verstek: inkomende += inChar; breek; }}

/* inkomende osc -boodskap word na die oscEvent -metode gestuur. */ void oscEvent (OscMessage theOscMessage) {float value = theOscMessage.get (0).floatValue (); // kry die 1ste osc -argument

IncomingOSCMessage + = "\ n" + String.format ("### het 'n osc -boodskap ontvang:" + "addrpattern:" + theOscMessage.addrPattern () + ": %f", waarde); println (IncomingOSCMessage); }

Stap 3: Kode Arduino

/* Hierdie kode is 'n basiese skets om te kommunikeer met Processing through Serial.

Dit is 'n bloudruk waarin u u eie kode vir u eie knoppies, potensiometers of sensors kan plaas.

Dit het 'n handdruk om seker te maak dat ons kontak het, en die formaat waarin ons kommunikeer, word bepaal

Dit is belangrik om die boodskap op dieselfde manier te konstrueer, sodat Processing weet hoe om dit te dekonstrueer en die korrekte OSC-boodskappe na ons DAW te stuur

gemaak vir werkcollege AV&IT Oktober 2017

kode smooothing geskep 22 Apr 2007 deur David A. Mellis aangepas 9 Apr 2012 deur Tom Igoe

*/

/ baud rate const long baudRate = 115200;

// tyd om te wag in ms tussen meningspeilings na die penne const int loopPauseTime = 200; // milli sekondes

// begin- en eindwaardes vir die boodskap wat gestuur word op Serial const String startString = "*", endString = "#";

const char contactCharacter = '|';

// pin id's const int buttonPin1 = 2; const int buttonPin2 = 5; const int numReadings = 5; // rate van smoothing

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

// ander globale veranderlikes int buttonState1 = 0; int buttonState2 = 0; // veranderlike vir die lees van die drukknop -status vlotter sensorValue1 = 0; float sensorValue2 = 0; float sensorValue3 = 0;

// gladde lesings [numReadings]; // die lesings van die analoog invoer int readIndex3 = 0; // die indeks van die huidige lesing int total3 = 0; // die lopende totale vlot gemiddelde3 = 0; // die gemiddeld

// Ons het hierdie funksie nodig om kontak te maak met die verwerkingskets // Hou dit hier ongeldig establishmentContact () {while (Serial.available () <= 0) {Serial.print (contactCharacter); // stuur 'n char en wag vir 'n antwoord … vertraging (loopPauseTime); } Serial.read (); }

ongeldige opstelling () {// stel die pinModes vir al die pins pinMode (buttonPin1, INPUT) in; pinMode (buttonPin2, INPUT); pinMode (pitchReading, INPUT); pinMode (speedReading, INPUT); pinMode (infraReading, INPUT);

// begin Serial comms Serial.begin (baudRate); terwyl (! Serial); // smoothing for (int thisReading = 0; thisReading <numReadings; thisReading ++) {readings [thisReading] = 0; }

// wag vir 'n handdruk, createContact (); }

void loop () {// poll all the pins and map the reading to the appropriate range buttonState1 = digitalRead (buttonPin1); buttonState2 = digitalRead (buttonPin2); sensorValue1 = analogRead (pitchReading); sensorValue2 = analogRead (speedReading); sensorValue3 = analogRead (infraReading);

// die inkomende waardes in kaart bring na die nodige waardes 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);

// smoothing sensor: total3 = total3 - lesings [readIndex3]; // gelees vanaf die sensor: lesings [readIndex3] = sensorValue3; // voeg die lesing by die totaal: total3 = total3 + lesings [readIndex3]; // gaan na die volgende posisie in die skikking: readIndex3 = readIndex3 + 1;

// as ons aan die einde van die skikking is … if (readIndex3> = numReadings) {// … draai om na die begin: readIndex3 = 0; } // bereken die gemiddelde: average3 = (total3 / numReadings); // stryk sensor

Serial.print (startString); // begin 'n boodskapreeks // skakel die naam, waardepare, geskei deur kommas 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 (","); Reeks.afdruk (gemiddeld3/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);

// skryf die einde van die boodskap Serial.print (endString);

// wag 'n rukkie..

vertraging (loopPauseTime); }

Stap 4: Maaier

Stap 1: Gaan na opsies> Voorkeure

Stap 2: Gaan na voorkeure na Control/OSC/web en druk op Add

Stap 3: Kies by Control oppervlakmodus vir OSC (Open Sound Control)

Stap 4: Vul die naam van u toestel in, kyk Ontvang 'n aan -en -vul -adres in die verwerking van Sendport -staat

Stap 5: Kopieer die gasheer -IP wat u hier en in die verwerking kan sien

Stap 6: Druk op ok en die controller is nu verbonden with Reaper

Stap 5: Behuizing

Breedte: 170 mm

Lengte: 90 mm

Hoogte 30 mm

Knoppen: 16 mm (deursnee

Potensiometer: 3 mm (deursnee)

Afstandsensor: Breedte 2,9 mm

Lengte 0,8 mm

Materiaal: MDF (3 mm)

Stap 6: Elektronika

Stap 1:

Verbind die grond en 5 volt van Arduino met die broodplank

Stap 2:

Verbindingspen A0 met potensiaal 1

Verbindingspen A1 met potensiaal 2

Verbindingspen A3 met infraroodsensor.

Verbind pin A2 met die nie -klewerige knoppie.

Verbind pin A5 met die klewerige knoppie.

Stap 7: Medewerkers

- Mayes El Baba

- Arno Gorissen

- Michiel De Wandelaer