DJ+Arduino+home+page

Grupo:
 * Igor Fernandes Castro - 0040441223041

Dispositivo:
 * Arduino Nano IO Shield

Projeto:
 * Dj Arduino

Resumo:

> Utilizando um Arduino para se comunicar com o piezoelétrico do prato de bateria eletrônica e o alto-falante.
 * O objetivo do trabalho é fazer uma bateria eletrônica.

Hardware Utilizado:
 * Arduino Nano


 * Pratos de bateria eletrônica(equipado com sensores piezoelétricos)




 * ProtoBoard




 * Fiação Macho-Fêmea/Macho-Macho/Fêmea-Fêmea.



Softwares Utilizados:

Arduino Software

Processing 2

Biblioteca utilizada

Metodologia:

O Objetivo inicial do trabalho era fazer com que ao tocar os sensores piezoelétricos, um auto-falante externo emitisse um som de bateria. No decorrer do trabalho abandonamos essa ideia e partimos para o processing 2(Uma plataforma de programação semelhante a do arduino) que faz com que o som seja emitido diretamente do computador. Utilizamos um Arduino Nano como plataforma de trabalho, conectado a alguns pratos de bateria elétrica(como as do Guitar Hero) como segue na imagem abaixo:



No arduino software, foi carregado o código abaixo(Código comentado):




 * arDRUMino - Aplicação Arduino




 * Apartir da leitura analógica de elementos piezoelétricos, são capitados golpes dados nos pads e os dados da leitura


 * (porta e intensidade) são transferidos, por porta serial, à um programa escrito na linguagem Processing .


 * Este programa, por sua vez, é responsável por transformar os dados recebidos do Arduino em sons MIDI com o auxilio da


 * biblioteca SoundCipher .





//int ledPin = 13;// led para indicação de início de leitura /* Arrays de controle */
 * 1) define QTD_SENSOR 2 //Quantidade de pinos que estão ligados à elementos piezo//

int sensores[QTD_SENSOR] = {0,5}; //pinos analógicos onde estão ligados os sensores de golpe//

//byte valLeitura[QTD_SENSOR];// variavel que armazena os valores lidos nos pinos dos sensores

int contSemBatidas[QTD_SENSOR]; //para cada sensor, conta quantos ciclos do loop ficou sem receber batidas (evita erros de leituras repetidas para uma mesma batida)//

//boolean bateu[QTD_SENSOR];// para cada sensor, controla indicação se o mesmo está em estado de batida int ligado = LOW; // variável usada para armazenar o status da aplicação e ligação do led para início de leitura /*


 * Variáveis do controle de suavização da leitura. Utilizado exemplo "Smooth" do site Arduino Playground


 * 



float filterVal; //controla grau de suavização da leitura - .0001 is max 1 is off (no smoothing)//

//float smoothedVal[QTD_SENSOR];// mantém a última leitura suavizada para cada um dos sensores void setup {

pinMode(ledPin, OUTPUT); //declera o ledPin como uma saida//

//Serial.begin(9600);// usar a porta serial

filterVal = .5; //aponta grau de suavização//

//}// //void loop {//

//for (int c=0; c<QTD_SENSOR; c++) {//

//valLeitura[c] = analogRead(sensores[c]);//

//smoothedVal[c] = smooth(valLeitura[c], filterVal, smoothedVal[c]);//

Se a leitura estiver liberada, o valor obtido da leitura do sensor ultrapassar em 5% a última leitura suavizada do mesmo

//e o sensor não estiver com indicação de batida ligado, a porta e a intensidade da batida (em %) é enviado para a porta serial.//

Para evitar problema de releitura de uma mesma batida, é implementado o controle baseado em loops sem batidas e indicação de batida,

//que só é liberado quando passar por mais de três leituras do mesmo sensor sem nenhuma leitura superior aos 5% da última suazização.//

//if (ligado && smoothedVal[c] > 0 && (int)valLeitura[c] > smoothedVal[c]*1.05) {//

//int perc = ((int)valLeitura[c] - smoothedVal[c]) *100/ smoothedVal[c];//

//if (!bateu[c]) {//

//Serial.print(c);//

//Serial.print("-");//

//Serial.println(perc);//

//bateu[c] = true;//

//}//

//contSemBatidas[c]=0;//

//}//

//else {//

//contSemBatidas[c]++;//

//if (contSemBatidas[c]>3) {//

//bateu[c] = false;//

//}//

//}//

//delay(10);// espera curta para previnir sobrecarga na porta serial //Controle de ligação//

//if (millis > 2000 && !ligado) {//

//ligado = HIGH;//

//digitalWrite(ledPin, ligado);//

Aponta inicio da leitura de batidas ao programa Processing

Serial.println("LIGOU!");

//Apontamento quantos sensores estão sendo utilizados ao programa Processing//

//Serial.print("SENSORES=");//

//Serial.println(QTD_SENSOR);//

//}//

//}//

//}//

Método do controle de suavização de leitura

int smooth(int data, float filterVal, float smoothedVal){

if (filterVal > 1){ // check to make sure param's are within range

filterVal = .99;

}

else if (filterVal <= 0){

filterVal = 0;

} smoothedVal = (data * (1 - filterVal)) + (smoothedVal * filterVal); return (int)smoothedVal;

} ||

No processing, foi carregado o código abaixo(Código comentado):




 * arDRUMino - Aplicação Processing




 * Esta aplicação recebe, por porta serial, valores (porta e intensidade) obtidos da leitura analógica de elementos piezoelétricos,


 * conectados ao Arduino . Utilizando a biblioteca SoundCipher , que possibilita trabalhar


 * com a interface MIDI do computador maneira bem simples, este programa transformar os dados recebidos do Arduino em sinais sonoros.





import arb.soundcipher.*;

import processing.serial.*; //Variável para recebimento das mensagens da porta serial//

//Serial portaSerial;// Array de variáveis SoundCipher, onde serão instânciados objetos para cada um dos sensores que

//estiverem sendo utilizados//

//SoundCipher sc[];// Pré definição do array de notas, umas para cada umas das 6 portas analógicas do Arduino

int notas[] = {52,40,36,46,38,49}; //Canal (9=Bateria) e Instrumento inicial da aplicação//

//int canal = 9;//

//int instrumento = 0;// //void setup {//

Imprime em tela todas as portas seriais do computador

println(Serial.list); //Instância objeto para controle da porta serial de comunicação com o arduino,//

no meu caso é a segunda porta da minha lista.

portaSerial = new Serial(this, Serial.list[1], 9600); //não gera um serialEvent até um o próximo caracter de quebra de linha "\n"//

//portaSerial.bufferUntil('\n');// set inital background:

background(0);

} //As teclas "+" e "-" mudam o canal MIDI utilizado, fazendo variar o tipo de som que é emitido.//

O canal 9 é de bateria, os outros são para os outros instrumentos.

As teclas "*" e "/" mudam o instrumento utilizado. Isto não funciona para o canal 9.

void keyPressed {

if (key=='+' && canal<15) {

println("canal: " + (++canal));

}

else if (key=='-' && canal>0) {

println("canal: " + (--canal));

}

if (key=='*' && instrumento<127) {

println("canal: " + (++instrumento));

}

else if (key=='/' && instrumento>0) {

println("canal: " + (--instrumento));

}

} int millisUltima = 0;

void serialEvent (Serial portaSerial) {

//Obtem uma String ASCII da comunicação//

//String inString = portaSerial.readStringUntil('\n');// Quando recebe mensagem com o caracter "-", indica que se trata de uma leitura de um dos sensores, onde a

//a esquerda do "-" (posição 0 do split) está a porta que recebeu a batida, e a direita (posição 1 do split)//

está a intensiadade da batida

if (inString != null && match(inString, "-") != null) {

int valores[] = int(split(trim(inString),'-'));

println("piezo: " + valores[0] + " - leitura: " + valores[1] + " - difTempo: " + (millis-millisUltima)); int forca = valores[1]*4; sc[valores[0]].playNote(0, canal, instrumento, notas[valores[0]], forca, 3, 0.8, 64);

millisUltima = millis;

}

//As outras mensagens são apresentadas diretamente, e as mensagens com o termo "SENSORES" indicam//

quantos sensores estão sendo utilizados pelo Arduino, para instância dos objetos (tambores) dos

//SoundCipher.//

//else {//

//println(inString);//

//if (match(inString, "SENSORES") != null) {//

//String valores[] = split(trim(inString),'=');//

//int nSensores = int(valores[1]);//

//sc = new SoundCipher[nSensores];//

//for (int i = 0; i < sc.length; i++) {//

//sc[i] = new SoundCipher(this);//

//}//

//}//

//}//

//}// //void draw {//

Por enquanto não desenha nada!

} ||

Conclusão:

Houve bastante dificuldade em todo o trabalho, pois integrantes do grupo desistiram inesperadamente, portanto, toda a carga de realização do projeto caiu sobre mim, que contava com a ajuda dos outros.

Fica claro que sem o auxílio de companheiros de grupo, é mais complicado fazer um projeto de qualidade, já que tenho dificuldades em programação.

O trabalho apresenta algumas falhas que não consegui resolver, tais como:

Um problema com o threshold, onde o sensor piezoelétrico é muito sensível a vibração, fazendo com que o mínimo de vibração faça disparar o som de prato.

Um problema com a quantidade de sensores piezo. Quando é conectado o primeiro sensor piezo, o programa automaticamente o lê como um prato da bateria, quando se conecta o segundo sensor o programa reconhece como a caixa da bateria e assim que se conecta o terceiro sensor, era para fazer um som de bumbo, porém o som que sai é o dos dois primeiros juntos.

Para mim, foi um grande desafio trabalhar nesse projeto e gostaria muito que desse certo. Agradeço a ajuda e atenção do professor em todas as partes do projeto.