Mostrando postagens com marcador stringless guitar. Mostrar todas as postagens
Mostrando postagens com marcador stringless guitar. Mostrar todas as postagens

sexta-feira, 19 de abril de 2013

Modelos da Aplicação


A classe principal que controla a aplicação é a StringlessGuitarUI. Ela contém as variáveis de instância que representam os botões para cada acorde de um tom. No diagrama coloquei apenas uma para servir de exemplo. Logo abaixo, a classe ButtonHandler, onde se encontra a lógica de abertura de um arquivo áudio, é interna da StringlessGuitarUI. Ela é marcada com um + dentro de um círculo ligados por uma seta.





A ButtonFactory é uma classe que encapsula a instanciação de todos os botões da tela. ButtonHandler implementa uma interface ouvinte de eventos de clique em um botão - ActionListener. Destaquei o método que realiza essa operação:



public void actionPerformed(ActionEvent e) {
           InputStream in;
           if(e.getSource() == buttonEm_CMaior){
           try{
                in = new FileInputStream(new File("C:\\Users\\Thiago\\Downloads\\Em_C Maior.wav"));
                AudioStream audios = new AudioStream(in);
                AudioPlayer.player.start(audios);
              }
           catch(Exception ex){
                JOptionPane.showMessageDialog(null, ex);
           }
      }

Um destaque para a interação do usuário com a máquina, ao clicar em um botão. O evento actionPerformed é disparado para a classe que o tratará (ButtonHandler):



A classe InputStream instancia um objeto da classe FileInputStream, que passa como argumento um path de um arquivo áudio (no momento em que actionPerformed é executado). Logo, a classe AudioInputStream instancia um objeto da própria classe e este recebe como argumento o path do arquivo, criando uma dependência de parâmetros.




sábado, 29 de dezembro de 2012

Prévia da Interface Gráfica: Stringless Guitar - Parte 2


Um JComboBox, que permite ao usuário escolher dentre vários elementos, pode ter duas formas diferentes. O formato padrão é uma combo box não-editável, que caracteriza um botão e uma lista drop-down de itens. A outra, editável, caracteriza um campo de texto com um pequeno botão ao lado. O usuário pode digitar um valor no campo de texto ou clicar no botão para mostrar a lista de itens. Aqui segue as duas formas de combo boxes, da esquerda para a direita, respectivamente, editável e não-editável em Java:


An uneditable combo box                            An editable combo box
An uneditable combo box                         An editable combo box


Outros componentes que podem mostrar uma de várias possibilidades de escolhas são grupos de radio buttons e lists. Selecionar um botão de opção diferente força a remoção da seleção de todos os outros que estão selecionados. Os botões de opção são utilizados para representar opções mutuamente exclusivas (isto é, não é possível selecionar múltiplas opções no grupo ao mesmo tempo).

A intenção de usar dois combo boxes é de fornecer ao usuário duas listas de tons (maior/menor) contendo cada uma 8 possibilidades de acordes para serem tocados (que vão ser representados pelos botões do último post). Segue o código que implementa essa funcionalidade:


import javax.swing.JComboBox;
import javax.swing.JFrame;
import java.awt.Container;
import java.awt.FlowLayout;


public class JComboBoxTeste extends JFrame {


JComboBox comboBoxTomMenor;
JComboBox comboBoxTomMaior;

public JComboBoxTeste(){
super("Teste");
Container container = this.getContentPane();
container.setLayout(new FlowLayout());
String[] listaAfinacaoMaior = {"Selecione um tom maior","C", "Db", "D", "Eb", "E", "F", "F#", "G", "Ab", "A", "Bb", "B"};
String[] listaAfinacaoMenor = {"Selecione um tom menor","C", "C#", "D", "Eb", "E", "F", "F#", "G", "G#", "A", "Bb", "B"};

comboBoxTomMaior = new JComboBox(listaAfinacaoMaior);
container.add(comboBoxTomMaior);

comboBoxTomMenor = new JComboBox(listaAfinacaoMenor);
container.add(comboBoxTomMenor);


comboBoxTomMaior.setEditable(false);
comboBoxTomMenor.setEditable(false);
}



public static void main(String[] args) {
JComboBoxTeste j = new JComboBoxTeste();
j.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
j.setSize(250,150);
j.setVisible(true);
}

}







Fontes de Referência

DEITEL, H.M; DEITEL, P.J, Java, Como Programar -8ªed. – São Paulo: Prentice Hall, 2010.
http://docs.oracle.com/javase/tutorial/uiswing/components/combobox.html#eg


domingo, 23 de dezembro de 2012

Prévia da Interface Gráfica: Stringless Guitar - Parte 1


As funcionalidades de nossa interface gráfica, como anteriormente explicitadas, devem ser divididas em níveis de abstração para facilitar o entendimento e a programação. Para isso, vamos atacar o problema pelos seguintes pontos:


  1. JButtons (botões);
  2. JComboBox (lista de itens drop-down);
  3. Tratadores de evento: selecionar um item do JComboBox/clicar em um botão;
  4. Lógica de abrir arquivo de áudio (por URL ou especificar o caminho de um arquivo local C://).



Por enquanto, testamos separadamente para analisar o comportamento dos componentes Swing JButton e JComboBox. O código abaixo testa os 8 botões da aplicação que, no futuro vão aparecer na tela após ser selecionado um item da lista de afinações (JComboBox). Serão 8 botões diferentes para cada item dessa caixa selecionável, contendo um arquivo midi diferente.







 





import javax.swing.JFrame;
import javax.swing.JOptionPane;

import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;

public class ButtonFrame extends JFrame {
private JButton button1;
private JButton button2;
private JButton button3;

private JButton button4;
private JButton button5;
private JButton button6;
private JButton button7;
private JButton button8;

private ButtonHandler handler;

/*Em
Am
Dm
G
C
F
Bb
Bdim
*/
public void makeButtons(){ Container c = this.getContentPane(); setLayout(new FlowLayout()); button1 = new JButton("Em"); c.add(button1); button2 = new JButton("Am"); c.add(button2); button3 = new JButton("Dm"); c.add(button3); button4 = new JButton("G"); c.add(button4); button5 = new JButton("C"); c.add(button5); button6 = new JButton("F"); c.add(button6); button7 = new JButton("Bb"); c.add(button7); button8= new JButton("Bdim"); c.add(button8); }

public void tratarEventoBotao(ButtonHandler handler){ //cria novo ButtonHandler para tratamento de evento de botão handler = new ButtonHandler();
button1.addActionListener(handler); button2.addActionListener(handler); button3.addActionListener(handler); button4.addActionListener(handler); button5.addActionListener(handler); button6.addActionListener(handler); button7.addActionListener(handler); button8.addActionListener(handler); }

public ButtonFrame(){
super("Testando JButtons"); makeButtons(); tratarEventoBotao(handler);
}

private class ButtonHandler implements ActionListener{

@Override
public void actionPerformed(ActionEvent event) {
JOptionPane.showMessageDialog(ButtonFrame.this, String.format("Você clicou %s", event.getActionCommand()));

}

}

public static void main(String[] args) {

ButtonFrame b = new ButtonFrame();
b.setSize(250,140);
        b.setVisible(true);
}
}

quinta-feira, 9 de agosto de 2012

Esboço do Projeto

Agora há pouco, estávamos levantando alguns importantes materiais para a reformulação do nosso projeto, e nisso acabamos desenhando um novo modelo da guitarra. Segue o desenho abaixo, e conforme formos pesquisando, vamos atualizando.


segunda-feira, 11 de junho de 2012

Making Of

Ensaio da "banda" para a apresentação final.

Rodrigo -  Bateria
Thiago   -  Pandeiro;
Jefferson - Guitarra Base;
                Danilo   -  Arduino Stringless Guitar




Link para o vídeo no Youtube
Download

segunda-feira, 28 de maio de 2012

Código Fonte Intermediário do Projeto


int LDR0, LDR1, LDR2, LDR3;
void setup() {

   pinMode(A0, INPUT);
   pinMode(A1, INPUT);
   pinMode(A2, INPUT);
   pinMode(A3, INPUT);


   Serial.begin(9600);

}

void loop() {


  LDR0 = analogRead(A0);
  LDR1 = analogRead(A1);
  LDR2 = analogRead(A2);
  LDR3 = analogRead(A3);

{

//-------------------------------- 
//Definição das Notas.
//--------------------------------  

  if (LDR1 >= 990){
    tone (9, 587);
}
  else if (LDR2 >= 990){
    tone(9, 523);
}
  else if (LDR3 >= 990){
    tone (9, 659);
}
  else if (LDR0 >= 900){
    tone (9, 699);
}
  else {
    noTone(9); 
}

//-------------------------------- 
//Serial Prints
//-------------------------------- 

 
Serial.print(" "); 
Serial.print(" ");
Serial.print(LDR0);
Serial.print(" "); 
Serial.print(" ");
Serial.print(LDR1);
Serial.print(" "); 
Serial.print(" ");
Serial.print(LDR2);
Serial.print(" "); 
Serial.print(" ");
Serial.print(LDR3);
}

Serial.println(); // imprime em linhas

delay(10);

}

terça-feira, 22 de maio de 2012

Apresentação Intermediária

Hoje foi o dia da segunda apresentação do projeto. Embora houve dificuldades na implementação com o shape pronto, conseguimos contornar esse problema com uma solução que vai ser melhorada para a última avaliação.

Materiais Utilizados:
  • Plug jack fêmea;
  • Jumpers;
  • LDR's;
  • Caixa de som;
  • Protoboard;
  • Resistores;
  • Shape da Guitarra
Materiais necessários para terminar o projeto: 
  • Bateria para o Arduino (adaptador 9V jack barrel);
  • Expansor de Portas Analógicas;
  • mais LED's e LDR's.
Para a apresentação final, será elaborado um artigo e um banner. Iremos comprar os materiais acima e trabalhar na solução.


Download da Apresentação Intermediária

domingo, 20 de maio de 2012

Montagem da Guitarra

Ontem o grupo se reuniu na oficina do luthier para que finalmente pudéssemos adquirir um protótipo para o nosso instrumento. Por conveniência, ele achou mais fácil modelar uma guitarra do tipo flying-V. As fotos abaixo seguem o passo-a-passo de um longo dia de trabalho.


















segunda-feira, 14 de maio de 2012

Preparação para a Apresentação Intermediária

Praticamente na reta final, estamos contentes com a evolução do nosso projeto. O grupo todo empenhou-se com muito afinco desde o começo do semestre. A falar em grupo, um novo integrante agora faz parte do nosso. Trata-se também de um músico, o Jefferson, que vai facilitar a aquisição do shape de guitarra por um preço muito mais viável. Nesse sábado iremos nos reunir e conversar com o luthier (quem constrói shapes de instrumento) para poder fazer os ajustes finais para a apresentação de Terça, 22/05.


Segunda-feira postaremos o link da apresentação para download. O que mudou, em relação ao projeto inicial, foi:

  1. Lasers - Utilizamos LED's devido à nossa melhor afinidade com o uso do mesmo;
  2. Sistema de chaves-botão - As notas serão emitidas, conforme a proximidade da mão ao braço da guitarra (uso de LED/LDR);
  3. O Modelo - Na postagem  Primeira Atualização do Projeto , há um novo desenho.

Teste de Música - Smoke On The Water

Estivemos testando agora há pouco um trecho de uma música do Deep Purple - Smoke On the Water. Abaixo segue o código-fonte e o vídeo:
--------------------------------------------------------------------------------------------------------------------------------------------------------------
unsigned long tempo; //declara tempo

void setup() {
     pinMode(9,OUTPUT);
     Serial.begin(9600);
}

void loop() {
     tempo= millis(); // base de tempo para a coleta
{

Serial.print(tempo);
Serial.print(" "); // introduz um espaço entre as colunas

tone(9,82);
delay (600);
tone(9,98);
delay (800);
tone(9,110);
delay (1000);

tone(9,82);
delay (600);
tone(9,98);
delay (800);
tone(9,117);
delay (400);
tone (9,110);
delay (1000);



tone(9,82);
delay (600);
tone(9,98);
delay (800);
tone(9,110);
delay (800);
tone(9,98);
delay (600);
tone(9,82);
delay (1000);

noTone(9);
delay (1000); 
}

Serial.println(); 

delay(100);

}
------------------------------------------------------------------------------------------------------------------------------------------------------------------




segunda-feira, 7 de maio de 2012

Materiais - Atualização


  • LED's;
  • LDR's;
  • Jumpers;
  • Arduino Duemilanove;
  • Protoboard;
  • Plug-in Jack Audio + Caixa de Som;
  • Shape de guitarra;   (orçado em R$300,00, o preço é inviável. Procuraremos preços de shape de madeira (violão), posteriormente).




Montagem do Circuito

Agora, com todos materiais adquiridos, o grupo se reuniu no dia 01/05 para realizar a primeira montagem do circuito com Arduino. Foram testados os LEDs, LDRs e jumpers, emprestados pelo laboratório da faculdade. Embora alguns estivessem queimados, o teste foi um sucesso.

A figura abaixo esquematiza um LED apontado para um LDR, a fim de se produzir uma corda. As frequências obtidas, para o LED apontando para o LDR variou na faixa de 180 a 200; e 800 a 900, para quando não havia nenhum objeto interagindo com o mesmo. Todos valores são aproximados.



A próxima etapa se baseia na programação a fim de reproduzir notas musicais, ao aproximar a mão da protoboard. Para isso, serão necessários uma caixa de som e um plug jack audio.

sábado, 21 de abril de 2012

Primeira Atualização do Projeto


Após algumas discussões sobre o nosso projeto inicial, hoje tivemos a ideia de implementar LEDs ao braço da guitarra, assim como no corpo; ao invés de lasers pointer, como havia sido publicado anteriormente. A utilização de LED's será de melhor custo-benefício, principalmente pelo seu tempo de duração. Abaixo segue o esboço do modelo.




A respeito do andamento do trabalho, as últimas semanas foram destinadas à pesquisa dos materiais. Até o fim do mês teremos adquirido-os todos, a saber:
  1. Arduino Duemilanove;
  2. LEDs;
  3. Protoboard / jumpers;
  4. LDR's / resistores.
Testaremos o código-fonte, baseado nos experimentos Led Blinking e Tone para começarmos, de fato, as etapas seguintes de programação. Isto será feito a partir da primeira semana de maio.

sábado, 31 de março de 2012

Arduino Stringless Guitar: Apresentação Inicial e Definição de Projeto com Cronograma.

Objetivo


Após varias discussões sobre o que viria ser uma ideia de projeto, decidimos, com base nos nossos gostos pessoais, que iríamos desenvolver um instrumento musical, no caso uma guitarra. O diferencial nesse projeto é a substituição das cordas físicas por feixes de luz. Daí, é instantâneo o título do projeto: Arduino Stringless Guitar.

Pretendemos, portanto, simular esses feixes com lasers pointers (ou leds) acoplados onde costuma-se ir as cordas de uma guitarra. Ao lado do Arduino, é claro, conectado com 6 LDRs. Para tocar as notas desejadas, utilizaremos chaves-botão do tipo arduino-shield. No código-fonte, haverá uma condição booleana que verificará o valor da resistência do LDR e a partir disso emitirá uma nota, se você apertar um dos botões, ou o som das cordas tocadas juntas, caso contrário.

Materiais necessários

  • shape de madeira;
  • arduino duemilanove;
  • chave-botão tipo arduino shield (qtd não definida);
  • lasers ou leds - 6;
  • ldr - 6



Cronograma do Projeto


Apresentação Inicial - 27/03

Nota do blog - 03/04

Montagem/Programação/Testes (código)

Abril - 14/04, 28/04

Maio - 05/05, 12/05, 19/05

Nota do blog - 07/05

Oficina Arduino - 08/05

Pesquisa sobre Materiais - 11/05

Apresentação Intermediária - 22/05

Ajustes finais (artigo, elaboração de cartaz, correção de código, relatórios)

26/05, 01/06, 02/06, 09/06

Nota do blog - 05/06

Apresentação Final - 12/06