Retro Controller: 7 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:39

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 foi om een controller te maken dat lijkt op een cassette.

Etapa 1: Wat Heb Je Nodig?

Componenten

- 2 botões;

- 2 Potentio metros;

- 2 pesos (1K alces);

- Arduino uno / nano

- Draadjes (esquema zie elektronisch)

- Soldeerplaat

- placa de MDF

Ferramentas

- Lasercutter

- Kniptang

- Striptang

- Soldeerbout (encontrou o estanho)

Do programa

- Ilustrator / indesign (Tekenprogramma)

- Reaper

- Em processamento

- Arduino

Etapa 2: Processamento de código

/**

* Esboço básico para receber mensagens seriais do Arduino * e traduzi-las em mensagens OSC para Reaper * * Você precisará adaptar os PARÂMETROS DO USUÁRIO * e precisará instalar uma Biblioteca: oscP5 * * feito para werkcollege AV&IT * por annoo bob eddi * out 2017 * * / ///////////////////// USER PARAMETERS ////////////////////// ////////

/ certifique-se de usar a mesma taxa de transmissão em seu esboço do Arduino final int baudRate = 115200;

// Vá e procure o endereço IP no Reaper ao usar OSC // Este é o endereço que o Processing envia e o Reaper escuta. // Coloque esta string em remoteIP, aqui.

// String final remoteIP = "192.168.1.43"; //por exemplo. "127.0.0.1";

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

// Anote o sendPort e preencha no Reaper. // Esta é a porta para a qual o Processing envia e o Reaper escuta.

final int listenPort = 11000, sendPort = 12000;

// O listenPort aqui é para depurar ativamente.

// os portNames também estão aqui para depurar.

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

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

///////////////////////// END of USER PARAMETERS ///////////////////////////// ////

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

import oscP5. *; import netP5. *;

OscP5 oscP5; NetAddress myRemoteLocation;

Serial commsPort; // O booleano da porta serial messageArrived = false;

Sequência de entrada = "", IncomingOSCMessage = "";

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

// Para ter certeza de que enviamos apenas os parâmetros (valores) que mudam // essas variáveis globais são delcaradas aqui, mas // não devem ser inicializadas aqui! HashMap oldParams, newParams, toSendParams;

// Precisamos dividir a mensagem a cada vírgula void processIncoming () {String resVec = entrando.split (","); // obtemos pares nome + valor // então para cada nome (+2)… try {for (int i = 0; i <resVec.length; i + = 2) {float value = Float.parseFloat (resVec [i + 1]); // coloque-os no novo Hashtable newParams.put (resVec , value); }} // se ocorrer um erro, vamos exibi-lo e sair. catch (Exceção de exceção) {println ("Mensagem de exceção:" + ex); printArray (resVec); saída(); }}

// Para filtrar nossas mensagens / * Nós nos certificamos de que há apenas uma mensagem OSC-out quando * a mensagem de entrada (Serial) muda * Isto é: se girarmos / apertarmos o botão e ele mudar o valor. * Portanto, filtramos os valores de entrada que realmente mudam * nota: não evitaremos valores saltados * como vêm de, por exemplo, acelerômetros ou sensores de distância * você precisará suavizá-los no Arduino * / void filterParams () {toSendParams = new HashMap (); for (String key: newParams.keySet ()) {// se a chave já estiver presente if (oldParams.containsKey (key)) {// chave presente e valor diferente, então atualize if (! oldParams.get (key)).equals (newParams.get (key))) {toSendParams.put (key, newParams.get (key)); }} else {// a chave não está presente nos parâmetros antigos, então coloque! 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)); / * enviar a mensagem * / oscP5.send (myMessage, myRemoteLocation); }}

void translateMessage () {processIncoming (); filterParams (); makeOSC (); } // Quando queremos imprimir na janela void ShowIncoming () {// para ver a mensagem recebida, conforme definido no texto HashMap ("Incoming from Arduino", 20, 20); int y = 20; for (String key: newParams.keySet ()) {y = y + 20; texto (chave, 20, y); texto (newParams.get (chave), 300, y); }}

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

configuração vazia () {tamanho (1000, 800); // Preenchimento do tamanho do palco (255); fundo (0); oldParams = new HashMap (); newParams = new HashMap (); // printArray (Serial.list ()); commsPort = novo Serial (this, portName, baudRate);

/ * iniciar oscP5, ouvindo mensagens de entrada * / oscP5 = new OscP5 (this, listenPort);

/ * myRemoteLocation é um NetAddress. um NetAddress leva 2 parâmetros, * um endereço IP e um número de porta. myRemoteLocation é usado como parâmetro em * oscP5.send () ao enviar pacotes osc para outro computador, dispositivo, * aplicativo. uso veja abaixo. para fins de teste, a porta de escuta * e a porta do endereço do local remoto são iguais, portanto, você * enviará mensagens de volta para este esboço. * / myRemoteLocation = new NetAddress (remoteIP, sendPort); }

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

void serialEvent (Serial commsPort) {// lê um byte da porta serial: char inChar = commsPort.readChar (); switch (inChar) {case contactCharacter: commsPort.write (contactCharacter); // pedir mais println ("começando…"); pausa; case startChar: entrando = ""; pausa; case endChar: messageArrived = true; // println ("fim da mensagem"); pausa; padrão: entrada + = inChar; pausa; }}

/ * as mensagens osc recebidas são encaminhadas para o método oscEvent. * / void oscEvent (OscMessage theOscMessage) {float value = theOscMessage.get (0).floatValue (); // obtém o primeiro argumento osc

IncomingOSCMessage + = "\ n" + String.format ("### recebeu uma mensagem osc:" + "addrpattern:" + theOscMessage.addrPattern () + ":% f", valor); println (IncomingOSCMessage); }

Etapa 3: codificar o Arduino

/ * Este código é um esboço básico para se comunicar com o Processing through Serial.

É um plano no qual você pode colocar seu próprio código especificado para seus próprios botões, potenciômetros ou sensores.

Tem um aperto de mão para garantir que temos contato e o formato em que estamos nos comunicando é decidido

É importante construir a mensagem da mesma maneira, para que Processing saiba como desconstruí-la e enviar mensagens OSC corretas para nosso DAW

feito para a werkcollege AV&IT outubro de 2017

código smooothing criado em 22 de abril de 2007 por David A. Mellis modificado em 9 de abril de 2012 por Tom Igoe

*/

/ taxa de baud const long baudRate = 115200;

// tempo de espera em ms entre as pesquisas para os pinos const int loopPauseTime = 200; // milisegundos

// valores inicial e final para a mensagem enviada em Serial const String startString = "*", endString = "#";

const char contactCharacter = '|';

// pin id's const int buttonPin1 = 2; const int buttonPin2 = 5; const int numReadings = 5; // taxa de suavização de van

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

// outras variáveis globais int buttonState1 = 0; int buttonState2 = 0; // variável para leitura do status do botão de pressão float sensorValue1 = 0; float sensorValue2 = 0; float sensorValue3 = 0;

// suavizando leituras internas [numReadings]; // as leituras da entrada analógica int readIndex3 = 0; // o índice da leitura atual int total3 = 0; // o float total em execução média3 = 0; // a média

// Precisamos desta função para estabelecer contato com o esboço de processamento // Mantenha-o aqui void activateContact () {while (Serial.available () <= 0) {Serial.print (contactCharacter); // envia um char e espera por uma resposta… delay (loopPauseTime); } Serial.read (); }

void setup () {// define os pinModes para todos os pinos pinMode (buttonPin1, INPUT); pinMode (buttonPin2, INPUT); pinMode (pitchReading, INPUT); pinMode (speedReading, INPUT); pinMode (infraReading, INPUT);

// inicializa a comunicação Serial Serial.begin (baudRate); while (! Serial); // suavização para (int thisReading = 0; thisReading <numReadings; thisReading ++) {leituras [thisReading] = 0; }

// aguarde o handshake EstablecerContato (); }

void loop () {// pesquisa todos os pinos e mapeia a leitura para o intervalo apropriado buttonState1 = digitalRead (buttonPin1); buttonState2 = digitalRead (buttonPin2); sensorValue1 = analogRead (pitchReading); sensorValue2 = analogRead (speedReading); sensorValue3 = analogRead (infraReading);

// correspondência dos valores de entrada com os valores necessários sensorValue1 = map (sensorValue1, 0, 1023, 0, 100,0) / - 100,0; sensorValue2 = map (sensorValue2, 0, 1023, 0.0, 100) /100.0; sensorValue3 = mapa (sensorValue3, 0, 700, 50, 100);

// sensor de suavização: total3 = total3 - leituras [readIndex3]; // ler do sensor: readings [readIndex3] = sensorValue3; // adiciona a leitura ao total: total3 = total3 + leituras [readIndex3]; // avança para a próxima posição no array: readIndex3 = readIndex3 + 1;

// se estivermos no final da matriz … if (readIndex3> = numReadings) {// … voltar ao início: readIndex3 = 0; } // calcula a média: average3 = (total3 / numReadings); // sensor de suavização

Serial.print (startString); // inicia uma sequência de mensagem // wirte todos os pares de nome e valor, separados por vírgulas 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 (","); Serial.print (média3 / 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);

// escreve o final da mensagem Serial.print (endString);

// espere um pouco..

atraso (loopPauseTime); }

Etapa 4: Reaper

Stap 1: Opções Ga bovenaan naar> Prefrences

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

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

Stap 4: nome do dispositivo Vul je em, vink Recieve na porta aan en vul in wat er em processamento 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

Etapa 5: Behuizing

Breedte: 170 mm

Comprimento: 90 mm

Hoogte 30 mm

Knoppen: 16 mm (diâmetro

Potentio metros: 3 mm (diâmetro)

Sensor Afstand: Breedte 2,9 mm

Comprimento 0,8 mm

Material: MDF (3 mm)

Etapa 6: Elektronica

Stap 1:

Verbind de ground en 5 volts van Arduino com het breadboard

Stap 2:

Verbind pin A0 com potentio 1

Verbind pino A1 com potencial 2

Verbind pino A3 com sensor infravermelho.

Verbind pino A2 com botão de niet sticky.

Pino Verbind A5 com botão adesivo.

Etapa 7: Medewerkers

- Mayes El Baba

- Arno Gorissen

- Michiel De Wandelaer