Retro kontroler: 7 kroków

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:32

Wij zijn eerste jaar studenten za pomocą technologii multimedialnej i komunikacyjnej (Multec) w 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 kaseta, ons doel was om een kontroler te maken dat lijkt op een kaseta.

Krok 1: Wat Heb Je Nodig?

Komponenty

- 2 przyciski;

- 2 potencjometry;

- 2 weerstanden (1K łosia);

- Arduino uno/nano

- Draadjes (schemat zie elektronisch)

- Soldeerplaat

- płyta MDF

Narzędzia

- Wycinarka laserowa

- Kniptang

-Striptang

- Soldeerbout (met cyna)

Programy

- Ilustrator/indesign (Tekenprogramma)

- Żniwiarz

-Przetwarzanie

- Arduino

Krok 2: Przetwarzanie kodu

/**

* Podstawowy szkic, aby otrzymywać wiadomości Serial z Arduino * i tłumaczy je na komunikaty OSC dla programu Reaper * * Będziesz musiał dostosować PARAMETRY UŻYTKOWNIKA * i będziesz musiał zainstalować Bibliotekę: oscP5 * * wykonane dla werkcollege AV&IT * przez annoo bob eddi * paź 2017 * */ ///////////////////// PARAMETRY UŻYTKOWNIKA //////////////////// ////////

/ upewnij się, że używasz tej samej szybkości transmisji w końcowym szkicu Arduino int baudRate = 115200;

// Idź i poszukaj adresu IP w programie Reaper podczas korzystania z OSC // Jest to adres, na który Processing wysyła, a Reaper nasłuchuje. // Umieść ten ciąg w remoteIP, tutaj.

//final String remoteIP = "192.168.1.43"; //np. „127.0.0.1”;

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

// Zanotuj sendPort i wypełnij go w programie Reaper. // To jest port, do którego Processing wysyła, a Reaper nasłuchuje.

końcowy port nasłuchu = 11000, port wysyłania = 12000;

// ListenPort służy do aktywnego debugowania.

// Nazwy portów również służą do debugowania.

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

// końcowy String nazwa_portu = "COM6"; // "/dev/ttyUSB0";

///////////////////// KONIEC PARAMETRÓW UŻYTKOWNIKA ///////////////////////// ////

importowanie przetwarzania.serial.*; import java.util.*;

importuj oscP5.*; importuj siećP5.*;

OscP5 OscP5; NetAddress mojaZdalnaLokalizacja;

Port komunikacji szeregowej; // Wartość logiczna portu szeregowego MessageArrived = false;

Ciąg przychodzący = "", IncomingOSCMessage = "";

końcowy znak startChar = '*', endChar = '#'; końcowy znak contactCharacter = '|';

// Aby upewnić się, że wysyłamy tylko parametry (wartości), które zmieniają // te globalne zmienne są tutaj zadeklarowane, ale // nie powinny być tutaj inicjowane! HashMap oldParams, newParams, toSendParams;

// Musimy podzielić wiadomość po każdym przecinku void processIncoming() { String resVec = coming.split(", "); // otrzymujemy pary nazwa + wartość // więc dla każdej nazwy (+2)… try{ for (int i = 0; i< resVec.length; i+=2) { float value = Float.parseFloat(resVec[i+ 1]); // umieść je w nowej tablicy Hashtable newParams.put(resVec, value); } } // jeśli wystąpi błąd, przechwyćmy go i wyjdźmy. catch(Wyjątek ex){ println("Komunikat wyjątku: " + ex); printArray(resVec); Wyjście(); } }

// Aby filtrować nasze wiadomości /* Upewniamy się, że jest tylko komunikat OSC-out, gdy * zmienia się komunikat wejściowy (Serial) * To znaczy: jeśli przekręcimy/naciśniemy przycisk i zmieni on wartość. * Więc odfiltrowujemy przychodzące wartości, które faktycznie się zmieniają * uwaga: nie unikniemy przeskakiwania wartości * pochodzących np. z akcelerometrów lub czujników odległości * będziesz musiał je wygładzić samodzielnie w Arduino */ void filterParams() { toSendParams = new HashMap(); for (String key: newParams.keySet()) { // jeśli klucz jest już obecny if (oldParams.containsKey(key)) { // klucz obecny i wartość nie jest taka sama, a następnie zaktualizuj if (!oldParams.get(key).equals(noweParams.get(klucz))) { toSendParams.put(klucz, noweParams.get(klucz)); } } else{ // klucz nie występuje w starych parametrach, więc umieść go! toSendParams.put(klucz, noweParams.get(klucz)); } stareParams.put(klucz, noweParams.get(klucz)); } }

void makeOSC() { for (String key: toSendParams.keySet()) { OscMessage mojaWiadomość = new OscMessage("/"+ klucz); mojaWiadomość.add(toSendParams.get(klucz)); /* wyślij wiadomość */ oscP5.send(mojaWiadomość, mojaZdalnaLokalizacja); } }

void przetłumaczMessage() { processIncoming(); filtrParametry(); makeOSC(); } // Kiedy chcemy drukować do okna void ShowIncoming() { // aby zobaczyć przychodzącą wiadomość, jak ustawiono w HashMap text("Incoming from Arduino", 20, 20); int y = 20; for (String key: newParams.keySet()) { y = y+20; tekst(klucz, 20, y); text(noweParametry.get(klucz), 300, y); } }

void showOsc() { text(IncomingOSCMessage, 300, 200); Przychodząca wiadomość OSCM =""; }

void setup() { size(1000, 800); // rozmiar stołu montażowego fill(255); tło(0); oldParams = new HashMap(); newParams = new HashMap(); //printArray(Serial.list()); commsPort = new Serial(this, portName, baudRate);

/* uruchom oscP5, nasłuchuj nadchodzących wiadomości */ oscP5 = new OscP5(this, listenPort);

/* mojaZdalnaLokalizacja jest adresem sieciowym. NetAddress przyjmuje 2 parametry, * adres IP i numer portu. myRemoteLocation jest używany jako parametr w * oscP5.send() podczas wysyłania pakietów osc do innego komputera, * urządzenia, aplikacji. użycie patrz poniżej. do celów testowych port nasłuchiwania * i port adresu zdalnej lokalizacji są takie same, dlatego * wyślesz wiadomości z powrotem do tego szkicu. */ myRemoteLocation = new NetAddress(zdalnyIP, sendPort); }

void draw() { if (messageArrived) { background(0); przetłumaczWiadomość(); Pokażprzychodzące(); wiadomośćPrzybyła= fałsz; } showOsc(); }

void serialEvent(Serial commsPort) { // odczytaj bajt z portu szeregowego: char inChar = commsPort.readChar(); switch (inChar) { case contactCharacter: commsPort.write(contactCharacter); // poproś o więcej println("start…"); przerwa; case startChar: przychodzące= ""; przerwa; case endChar: messageArrived = true; //println("koniec wiadomości"); przerwa; domyślnie: przychodzące += inChar; przerwa; } }

/* przychodzące wiadomości osc są przekazywane do metody oscEvent. */ void oscEvent(OscMessage theOscMessage) { float value = theOscMessage.get(0).floatValue(); // pobierz pierwszy argument osc

IncomingOSCMessage += "\n" + String.format("### odebrano komunikat osc: " + " addrpattern: " + theOscMessage.addrPattern() + ": %f", value); println (Komunikat przychodzący OSCM); }

Krok 3: Kod Arduino

/* Ten kod jest podstawowym szkicem do komunikacji z Przetwarzaniem przez Serial.

Jest to plan, w którym można umieścić własny kod określony dla własnych przycisków, potencjometrów lub czujników.

Ma uścisk dłoni, aby upewnić się, że mamy kontakt, a format, w którym się komunikujemy, jest określony

Ważne jest, aby skonstruować komunikat w ten sam sposób, aby Processing wiedział, jak go zdekonstruować i wysłać prawidłowe komunikaty OSC do naszego DAW

stworzony dla werkcollege AV&IT październik 2017

wygładzanie kodu stworzone 22 kwietnia 2007 przez Davida A. Mellisa zmodyfikowane 9 kwietnia 2012 przez Toma Igoe

*/

/ szybkość transmisji const long baudRate = 115200;

// czas oczekiwania w ms między odpytywaniem pinów const int loopPauseTime = 200; // milisekundy

// wartości początkowe i końcowe wiadomości wysyłanej w Serial const String startString = "*", endString = "#";

const char contactCharacter = '|';

// identyfikator pinu const int buttonPin1 = 2; const int przyciskPin2 = 5; const int numReadings = 5; //oceniaj wygładzanie vana

int pitchReading = A1; int speedReading = A2; int odczyt na podczerwień = A3;

// inne zmienne globalne int buttonState1 = 0; int Stan przycisku2 = 0; // zmienna do odczytu stanu przycisku float sensorValue1 = 0; czujnik pływakowyValue2 = 0; czujnik pływakowyValue3 = 0;

//wygładzanie odczytów int[numReadings]; // odczyty z wejścia analogowego int readIndex3 = 0; // indeks bieżącego odczytu int total3 = 0; // bieżący total float średnia3 = 0; // Średnia

// Potrzebujemy tej funkcji do nawiązania kontaktu ze szkicem Processing // Zachowaj ją tutaj void EstablishContact() { while (Serial.available() <= 0) { Serial.print(contactCharacter); // wyślij znak i czekaj na odpowiedź… delay(loopPauseTime); } Serial.odczyt(); }

void setup() { // ustawienie pinModes dla wszystkich pinów pinMode(buttonPin1, INPUT); pinMode(buttonPin2, INPUT); pinMode(pitchReading, INPUT); pinMode(speedReading, INPUT); pinMode(InfraReading, INPUT);

// zainicjuj komunikację szeregową Serial.begin(baudRate); podczas (!Serial); //wygładzanie for (int thisReading = 0; thisReading < numReadings; thisReading++) { odczyty[tenCzyt] = 0; }

// czekaj na uzgadnianie ustanawiaKontakt(); }

void loop() { // odpytywanie wszystkich pinów i mapowanie odczytu na odpowiedni zakres buttonState1 = digitalRead(buttonPin1); buttonState2 = digitalRead(buttonPin2); sensorValue1 = analogRead (pitchReading); sensorValue2 = analogRead (speedReading); sensorValue3 = analogRead (infraReading);

//mapowanie przychodzących wartości na niezbędne wartości sensorValue1 = map(sensorValue1, 0, 1023, 0, 100.0)/-100.0; sensorValue2 = mapa(sensorValue2, 0, 1023, 0.0, 100)/100.0; sensorValue3 = map(sensorValue3, 0, 700, 50, 100);

// czujnik wygładzający: total3 = total3 - odczyty[readIndex3]; // odczytaj z czujnika: readings[readIndex3] = sensorValue3; // dodaj odczyt do sumy: total3 = total3 + readings[readIndex3]; // przejdź do następnej pozycji w tablicy: readIndex3 = readIndex3 + 1;

// jeśli jesteśmy na końcu tablicy… if (readIndex3 >= numReadings) { // …zawiń do początku: readIndex3 = 0; } // oblicz średnią: Average3 = (total3 / numReadings); // czujnik wygładzania

Serial.print(startString); // uruchom sekwencję komunikatów // wpisz wszystkie nazwy, pary wartości, oddzielone przecinkami Serial.print("potentio1"); Serial.print(", "); Serial.print(WartośćCzujnika1); Serial.print(", ");

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

Serial.print("czujnik podczerwony"); Serial.print(", "); Serial.print(średnia3/100); Serial.print(", ");

Serial.print("knop 1 in2 dowcip"); Serial.print(", "); Serial.print(buttonState1); Serial.print(", "); Serial.print("knop2 in5 geel"); Serial.print(", "); Serial.print(buttonState2);

// napisz koniec wiadomości Serial.print(endString);

// Poczekaj chwilę..

opóźnienie (pętlaPauseTime); }

Krok 4: Żniwiarz

Krok 1: Ga bovenaan naar Opcje>Preferencje

Krok 2: Ga in prefrences naar Control/OSC/web en druk op Dodaj

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

Krok 4: Vul je nazwa urządzenia w, Vink Odbierz na porcie aan en vul w wodzie w przetwarzaniu bij Sendport staat

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

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

Krok 5: Behuowanie

Breedte: 170 mm

Długość: 90mm

Hoogta 30 mm

Knoppen: 16 mm (średnica

Potencjometry: 3 mm (średnica)

Czujnik odległościowy: Breedte 2,9 mm

Długość 0,8 mm

Materiał: MDF (3mm)

Krok 6: Elektronika

Krok 1:

Verbind de ground en 5 volt van Arduino met het breadboard

Krok 2:

Verbind pin A0 z potencjometrem 1

Verbind pin A1 z potencjometrem 2

Verbind pin A3 spotkał się z czujnikiem podczerwieni.

Pin do wiązania A2 z nieprzylepnym przyciskiem.

Przypinka A5 z przyklejonym guzikiem.

Krok 7: Medewerkerzy

- Mayes El Baba

- Arno Gorissen

- Michiel De Wandelaer