You are on page 1of 19

Arduino Baseado MIDI Expression Pedal

Por jeffb42 , jul 17, 2009




4.99 ( 43 votos)



Classifique esta: vote 1voto 2votos 3votos 4votos 5

emCompartilhar0
Download de projetos - 28,91 KB
Artigo 1 : Introduo ao Arduino Plataforma Hardware
Artigo 2: Interface um Arduino com LCDs

Introduo
Este o meu terceiro artigo sobre a plataforma de hardware Arduino e a concluso da
srie. Neste artigo, vou descrever como construir um pedal de volume MIDI usando um
microcontrolador Arduino.
Fundo
Eu tenho um processador de efeitos que eu constru uma cano em torno de onde eu
variar um dos parmetros como eu jogo. O dispositivo tem portas MIDI, mas no responde
ao controlador MIDI contnua (CC) de mensagens, no entanto pode-se alterar os
parmetros enviando o sistema MIDI dispositivo exclusivo (SysEx) mensagens. Eu poderia
ter implementado uma soluo apenas de software, mas eu queria um dispositivo stand-
alone e eu no quero ter que ligar um computador para o meu equipamento. Eu tambm
poderia ter implementado uma soluo de hardware usando apenas desligar os
componentes de prateleira, incluindo um pedal de expresso , um controlador MIDI Pedal
Solutions e um processador MIDI Solutions evento , mas este ainda seria um pouco
volumoso e eu queria algo mais compacto. Um dia me deparei com o site do Pequeno Urso
Eletrnica, que vende kits de pedais de expresso e eu tive a idia de combinar um
gabinete pedal com um microcontrolador e construir o meu primeiro dispositivo eletrnico
- um pedal de expresso personalizada que gera SysEx. Sei que este um caso muito
especializado e que um pedal de volume MIDI teria um apelo mais abrangente para que eu
tenha includo um esboo para um pedal de volume MIDI tambm.
Metronome2
Antes de eu comear a falar sobre a expresso esboos pedal, vamos rever o esboo
metrnomo eu apresentei no primeiro artigo. Se bem se lembram, o ritmo foi codificado
dentro do programa e se o tempo necessrio para ser mudado, o cdigo teve que ser
modificado e recompilado. Em Metronome2 eu adicionei um potencimetro 10K Ohm,
ligado ao pino analgico 0:

(Esta imagem um pouco difcil de fazer. Se voc ver a imagem ampliada, voc ser capaz de ver os
pinos do Arduino melhor.)

Os pinos analgicos tomar dispositivos 10K Ohm e tm um alcance de 0-1023. O esboo a
seguir exibe o valor do potencimetro medida que muda:
Recolher | Cdigo Copiar
/ / Raw valor potencimetro espectador

/ / Constantes
const int POT_PIN = 0 ; / / Pot ligado ao pino analgico 0
const int SERIAL_PORT_RATE = 9600 ;


vazio setup () / / Executar uma vez, quando o esboo
comea
{
Serial.begin (SERIAL_PORT_RATE); / / Inicia a comunicao com a porta serial
}

vazio loop () / / Executar uma e outra vez
{
int nValue = analogRead (POT_PIN);
Serial.println (nValue);
}
Se voc executar com o monitor serial, voc vai ver que temos um problema - mesmo
quando voc no tocar o potencimetro, o valor ainda muda. Este no foi um problema
com o esboo de esqui, pois s tem cinco valores (-2 atravs +2), mas com o esboo
Metronome2 (e mais tarde com o esboo pedal de volume), este ser um problema -
depois de definir o tempo, voc vai querer o ritmo a ser constante e no flutuar. Para
superar isso, o cdigo foi adicionado para suportar um limite e rejeitar valores muito
prximos do ltimo conhecido bom valor:
Recolher | Cdigo Copiar
/ / espectador potencimetro com limite

/ / Constantes
const int POT_PIN = 0 ; / / Pot ligado ao pino analgico 0
const int POT_THRESHOLD = 3 ; / / quantidade limite para se proteger
contra falsos valores
const int SERIAL_PORT_RATE = 9600 ;


vazio setup () / / Executar uma vez, quando o esboo
comea
{
Serial.begin (SERIAL_PORT_RATE); / / Inicia a comunicao com a porta serial
}

vazio loop () / / Executar uma e outra vez
{
static int s_nLastValue = 0 ;

int nValue = analogRead (POT_PIN);
se (abs (nValue - s_nLastValue) <POT_THRESHOLD)
retorno ;
s_nLastValue = nValue;

Serial.println (nValue);
}
Isso melhor, mas o cdigo ainda precisa ser levado um passo adiante. O cdigo precisa
ser mapeado para um valor que est dentro de uma faixa que est procurando, eo cdigo
precisa para se proteger contra o mesmo valor a ser definido:
Recolher | Cdigo Copiar
/ /
/ / check flutuante valor potencimetro contra limiar
/ /

/ / Constantes
const int POT_PIN = 0 ; / / Pot ligado ao pino analgico 0
const int POT_THRESHOLD = 3 ; / / quantidade limite para se proteger
contra falsos valores
const int SERIAL_PORT_RATE = 9600 ;

vazio setup () / / Executar uma vez, quando o esboo
comea
{
Serial.begin (SERIAL_PORT_RATE); / / Inicia a comunicao com a porta serial
}

vazio loop () / / Executar uma e outra vez
{
static int s_nLastPotValue = 0 ;
static int s_nLastMappedValue = 0 ;

int nCurrentPotValue = analogRead (POT_PIN);
se (abs (nCurrentPotValue - s_nLastPotValue) <POT_THRESHOLD)
retorno ;
s_nLastPotValue = nCurrentPotValue;

int nMappedValue = map (nCurrentPotValue, 0 , 1023 , 0 , 255 ); / / Mapa do
valor de 0-255
se (nMappedValue == s_nLastMappedValue)
retorno ;
s_nLastMappedValue = nMappedValue;

Serial.println (nMappedValue);
}
Se voc achar que este ainda muito barulhento (eu fiz, mas eu estava correndo um
potencimetro wah 200K em um pino que quer 10K), uma abordagem alternativa verificar
o valor contra um buffer de histrico:
Recolher | Cdigo Copiar
/ /
/ / check flutuante valor potencimetro contra tampo histria
/ /

/ / Constantes
const int POT_PIN = 0 ; / / Pot ligado ao pino analgico 0
const int POT_THRESHOLD = 3 ; / / quantidade limite para se proteger
contra falsos valores
const int HISTORY_BUFFER_LENGTH = 6 , / / buffer de Histria comprimento
/ / (para se proteger contra o rudo que est
sendo enviado)
const int SERIAL_PORT_RATE = 9600 ;

/ / Globals
esttica int s_history [HISTORY_BUFFER_LENGTH];

vazio setup () / / Executar uma vez, quando o esboo
comea
{
Serial.begin (SERIAL_PORT_RATE); / / Inicia a comunicao com a porta serial

/ / Inicializar ele tampo
para ( int i = 0; i <HISTORY_BUFFER_LENGTH; i + +)
{
s_history [i] = - 1 ;
}
}

vazio loop () / / Executar uma e outra vez
{
static int s_nLastPotValue = 0 ;
static int s_nLastMappedValue = 0 ;

int nCurrentPotValue = analogRead (POT_PIN);
se (abs (nCurrentPotValue - s_nLastPotValue) <POT_THRESHOLD)
retorno ;
s_nLastPotValue = nCurrentPotValue;

int nMappedValue = map (nCurrentPotValue, 0 , 1023 , 0 , 255 ); / / Mapear o
valor
/ / para 0-255
se (nMappedValue == s_nLastMappedValue)
retorno ;

para ( int i = 0; i <HISTORY_BUFFER_LENGTH; i + +)
{
se (s_history [i] == nMappedValue)
retorno ;
}

memcpy (& s_history [ 0 ], e s_history [ 1 ], sizeof ( int ) *
(HISTORY_BUFFER_LENGTH - 1 ));
s_history [HISTORY_BUFFER_LENGTH - 1 ] = nMappedValue;
s_nLastMappedValue = nMappedValue;
Serial.println (nMappedValue);
}
(O valor atual ser reenviado no um problema com o esboo do metrnomo, mas mais
tarde vamos precisar deste para o pedal de expresso.)
Agora, adicionando este apoio para o potencimetro no esboo do metrnomo, o cdigo
agora se parece com:
Recolher | Cdigo Copiar
/ *
* Metronome2
*
* Baseado no exemplo bsico Arduino, Blink:
* Http://www.arduino.cc/en/Tutorial/Blink
* Funciona como um metrnomo visual.
* /

/ / Constantes
const int LED_PIN = 13 ; / / LED conectado ao pino digital de 13
const int POT_PIN = 0 ; / / Pot ligado ao pino analgico 0
const int POT_THRESHOLD = 3 ; / / quantidade limite para se proteger
contra falsos valores

nulos setup () / / Executar uma vez, quando o esboo
comea
{
pinMode (LED_PIN, OUTPUT); / / Define o LED como sada
}

vazio loop () / / Executar uma e outra vez
{
static int s_nLastPotValue = 0 ;
static int s_nTempo = 0 ;

int nCurrentPotValue = analogRead (POT_PIN); / / Tem uma gama de 0-
1023
se (abs (nCurrentPotValue - s_nLastPotValue)> = POT_THRESHOLD)
{
s_nLastPotValue = nCurrentPotValue;
int nTempo = map (nCurrentPotValue, 0 , 1023 , 50 , 255 ); / / Mapear o valor
a 50-255
se (nTempo = s_nTempo!)
{
s_nTempo = nTempo;
}
}

/ / Atraso em milissegundos = 1 minuto 60 segundo 1000 milissegundos
/ / --------- * ---------- --------------- * -
/ / (X) bate minuto segundo
int nDelay = ( int ) (( 60 . 0 * 1000 . 0 ) / ( bia ) s_nTempo);
PlayNote (nDelay);
}

vazio PlayNote ( int nDuration)
{
nDuration = (nDuration / 2 );
digitalWrite (LED_PIN, HIGH); / / Defina o LED em
atraso (nDuration); / / Espera por metade do (original)
durao
digitalWrite (LED_PIN, LOW); / / Defina o LED off
delay (nDuration); / / Aguarde a metade (original) durao
}
VolumePedal
Existem vrios controladores de p MIDI atualmente no mercado, como o Roland FC-
300 eo Behringer FCB1010 , mas esses controladores do p so volumosos e se voc s
quer um nico pedal de expresso que eles so um pouco exagerado. Infelizmente, um
pedal de volume MIDI individual no existe no mercado neste momento, ento eu decidi
criar um usando um Arduino.
O envio de uma mensagem MIDI CC mudana de volume muito fcil e apenas trs bytes
precisam ser enviados:
Recolher | Cdigo Copiar
Comando de mudana de CC (0xB0 - - 0xBF dependendo do canal MIDI) 0xB0
0x07 - comando Volume
o valor - O valor do volume, entre 0 e 127
... Por isso os comandos MIDI reais enviados no so muito complicadas ou longas, no
entanto, o hardware eo software de suporte demorou um pouco de trabalho ... (no muito,
mas ainda algum trabalho e alguma tentativa e erro)
Antes de olhar para o cdigo-fonte, vamos passar por cima das peas. No mnimo, voc vai
precisar de:
Um processador Arduino. Para o meu pedal de expresso, eu usei um Arduino Pro Mini (a
verso 5V)
Um gabinete pedal de expresso
Um potencimetro wah (ele no vem com o gabinete pedal)
Um pedal de 3 plos
Um LED (embora este opcional)
A ficha de alimentao DC
Uma fonte de alimentao 9VDC
Um plug MIDI
A 220 Ohm resistente para a porta MIDI
Um resistor de 1K Ohm para o LED
A placa de ensaio de pr-montagem do circuito e verifique que as obras esboo
Uma placa de circuito em branco para soldar tudo em
Um conjunto de cabealhos para soldar o Arduino para a placa de circuito
Arame
O pedal de expresso gabinete que navios de pequeno urso Electronics inacabado e de
alumnio nu. Antes de montar o seu projeto, voc provavelmente vai querer pintar seu
gabinete. Eu enviei o meu para PedalEnclosures.com e teve o gabinete pintado em um
acabamento hammertone vermelho.
Quanto a fiao vai, j cobrimos como ligar o LED e potencimetro. Os nicos
componentes restantes so a entrada 9VDC, o pedal ea porta MIDI Out. Para a porta MIDI
Out, voc vai precisar para se conectar:
Pin 5 a TX0
Pino 2 para GND
O pino 4 de um resistor de 220 ohm, o qual ento ligado a uma fonte de alimentao de
+5 VDC (VCC)

Para a tomada de entrada 9VDC ea pedal, soldar o pedal para que ele interrompe o circuito
aps a + V na ficha de entrada:

... E agora tudo se conectar placa de ensaio:


A cmera que eu no era capaz de dar uma imagem muito boa de montagem final, por isso
aqui est um resumo de cada pino do Arduino Mini:
Top Row
RAW Pedal + V
GND Ficha de alimentao GND
RST
VCC + V rail
A3
A2
A1
A0
Resistor varivel Pot (conector do
meio)
13 LED
12
11
10
Bottom Row
TX0 MIDI Pino 5
RXI
RST
GND Trilho do cho
2
3
4
5
6
7
8
9
+ V Rail
220 Ohm resistor (conectado ao MIDI
Pin 4)
Pot + V
GND Rail MIDI Pino 2
1K resistor (ligado terra LED)
O cdigo fonte para o pedal de volume MIDI a seguinte:
Recolher | Cdigo Copiar
/ / # define DEBUG 1

/ / Constantes
const int LED_PIN = 13 ; / / LED conectado ao pino digital 13
const int POT_PIN = 0 ; / / Pot ligado ao pino analgico 0
const int POT_THRESHOLD = 7 ; / / quantidade limite para se proteger contra
falsos valores
const int MIDI_CHANNEL = 0 ; / / MIDI Canal 1

# Ifdef DEBUG
const int DEBUG_RATE = 9600 ; / / depurao Serial comunica em 9600
const int SERIAL_PORT_RATE = DEBUG_RATE;
# else
const int MIDI_BAUD_RATE = 31250 ; / / MIDI comunica a 31250 baud
const int SERIAL_PORT_RATE = MIDI_BAUD_RATE;
# endif


vazio setup ()
{
pinMode (LED_PIN, OUTPUT); / / Define o pino digital como sada
digitalWrite (LED_PIN, HIGH); / / Ligue o LED
Serial.begin (SERIAL_PORT_RATE); / / Inicia a comunicao com a porta
serial
}

vazio loop ()
{
static int s_nLastPotValue = 0 ;
static int s_nLastMappedValue = 0 ;

int nCurrentPotValue = analogRead (POT_PIN);
se (abs (nCurrentPotValue - s_nLastPotValue) <POT_THRESHOLD)
retorno ;
s_nLastPotValue = nCurrentPotValue;

int nMappedValue = map (nCurrentPotValue, 0 , 1023 , 0 , 127 ); / / Mapa do valor
de 0-127
se (nMappedValue == s_nLastMappedValue)
retorno ;
s_nLastMappedValue = nMappedValue;

MidiVolume (MIDI_CHANNEL, nMappedValue);
}

vazio MidiVolume (canal byte, o volume de bytes)
{
# Ifdef DEBUG
Serial.println (volume, DEC);
# Else
Serial.print (0xB0 | (canal & 0x0F), BYTE); / / Controle de mudana de
comando
Serial.print (0x07, BYTE); / / comando Volume
Serial.print (volume & 0x7F, BYTE); / / Volume 0 -127
# endif
}
Atravessar o cdigo, primeiro h:
Recolher | Cdigo Copiar
/ / # define DEBUG 1
Eu uso essa constante para definir ou no a construo uma compilao de
depurao. Para executar em modo de depurao, basta descomentar esta linha.
Em seguida, h as constantes:
Recolher | Cdigo Copiar
/ / Constantes
const int LED_PIN = 13 ; / / LED conectado ao pino digital de 13
const int POT_PIN = 0 ; / / Pot ligado ao pino analgico 0
const int POT_THRESHOLD = 7 ; / / quantidade limite para se proteger contra
falsos valores
const int MIDI_CHANNEL = 0 ; / / MIDI Canal 1

# Ifdef DEBUG
const int DEBUG_RATE = 9600 ; / / depurao Serial comunica em 9600
const int SERIAL_PORT_RATE = DEBUG_RATE;
# else
const int MIDI_BAUD_RATE = 31250 ; / / MIDI comunica a 31250 baud
const int SERIAL_PORT_RATE = MIDI_BAUD_RATE;
# endif
O LED indica que o aparelho est ligado. opcional, mas se voc anexar um LED, o LED
deve ser conectado ao pino digital 13 (e no se esquea do resistor e da orientao do
LED).
O potencimetro conectado ao pino analgico 0. As especificaes Arduino afirmar que
os pinos analgicos quer dispositivos com apenas resistncia 10K Ohm, no entanto
potencimetros wah (que o que vai usar com o pedal de expresso) s esto disponveis
em 100K e 200K. Eu comprei um potencimetro de 200K e descobriu que, embora fosse um
pouco barulhento, ele ainda trabalhava, e precisava definir o limite de 7:
Recolher | Cdigo Copiar
const int POT_THRESHOLD = 7 ; / / quantidade limite para se proteger contra
falsos valores
O prximo valor, o canal MIDI, deixado como uma constante codificado. Assim como o
esboo metrnomo, poderamos acrescentar um potencimetro para selecionar o canal
MIDI, mas para os meus propsitos eu s precisava de o canal MIDI fixo para um canal.
O prximo grupo de constantes diz respeito taxa de porta serial. Tanto a porta MIDI
eo print () comandos utilizados para depurar usar a porta serial e no coexistem
bem. Um precisa de ser tanto no modo de depurao ou modo de liberao para que eu
alternar entre os dois usando o # ifdef DEBUG cheque.
Em seguida est o cdigo. O setup () funo mnima e tpico do que j vimos at
agora:
Recolher | Cdigo Copiar
vazio setup ()
{
pinMode (LED_PIN, OUTPUT); / / Define o pino digital como sada
digitalWrite (LED_PIN, HIGH); / / Ligue o LED
Serial.begin (SERIAL_PORT_RATE); / / Inicia a comunicao com a porta
serial
}
A funo seguinte, ciclo () , contm a maior parte do cdigo:
Recolher | Cdigo Copiar
vazio loop ()
{
static int s_nLastPotValue = 0 ;
static int s_nLastMappedValue = 0 ;

int nCurrentPotValue = analogRead (POT_PIN);
se (abs (nCurrentPotValue - s_nLastPotValue) <POT_THRESHOLD)
retorno ;
s_nLastPotValue = nCurrentPotValue;

int nMappedValue = map (nCurrentPotValue, 0 , 1023 , 0 , 127 ); / / Mapa do valor
de 0-127
se (nMappedValue == s_nLastMappedValue)
retorno ;
s_nLastMappedValue = nMappedValue;

MidiVolume (MIDI_CHANNEL, nMappedValue);
}
s_nLastPotValue eo if (abs (nCurrentPotValue - s_nLastPotValue)
<POT_THRESHOLD) guardas verificar contra um potencimetro barulhento
e s_nLastMappedValue eo if (nMappedValue == s_nLastMappedValue)verifique se
proteger contra o envio do valor se fosse o ltimo valor enviado.
MidiVolume () onde os bytes so enviados. Como j foi mencionado anteriormente, a
apenas trs bytes so necessrios para enviar a mensagem de volume MIDI CC:
Recolher | Cdigo Copiar
vazio MidiVolume (canal byte, o volume de bytes)
{
# Ifdef DEBUG
Serial.println (volume, DEC);
# Else
Serial.print (0xB0 | (canal & 0x0F), BYTE); / / Controle de mudana de
comando
Serial.print (0x07, BYTE); / / comando Volume
Serial.print (volume & 0x7F, BYTE); / / Volume 0 -127
# endif
}
E isso. Se voc conectou o hardware corretamente, tudo deve funcionar neste
momento. No Windows, h um programa gratuito disponvel chamado MIDI-OX que
permite que voc veja todas as mensagens MIDI de entrada, e no Mac OSX, h um
programa gratuito disponvel chamado MIDI monitor que faz a mesma coisa. Se voc
executar um desses programas (e tem porta MIDI Out do seu pedal de expresso
conectado ao computador), voc deve ver as mensagens MIDI de volume CC vm em como
voc se move o potencimetro wah.
Montagem dos componentes finais
Neste ponto, eu estava pronto para cometer o projeto para a placa de circuito final e
montar os componentes. Eu transferi o desenho na placa de ensaio para a placa de circuito
e conectores adicionais para que eu pudesse facilmente adicionar e remover o componente
no diretamente na placa de circuito:

Esta foto foi tirada de perto. Ao fazer isso, a imagem produzida foi distorcida. O fio verde na parte
inferior conecta o pino 5 do conector MIDI para TX0, mas nesta imagem parece que a conexo RXI,
no TX0.

Placa de circuito lanado horizontalmente para mostrar back side (o trilho superior + V eo trilho
inferior GND).

Placa de circuito com componentes

Close-up das conexes da placa de circuito

Montagem interna de componentes
Ajustar o intervalo
Depois que o hardware foi totalmente montado, o pote wah no tinha mais a sua gama
completa de movimento (devido ao alcance limitado da placa superior) para que era
necessria uma mudana de cdigo menor. Quando o pote wah teve sua gama completa
de movimento, s_nLastPotValue tinha um alcance de 0-1023
es_nLastMappedValue tinha uma gama de 0-127. Com a gama
limitada s_nLastPotValue agora tinha um alcance de 0-1002
e s_nLastMappedValue tinha uma gama de 0-125. Eu atualizei loop () com uma
pequena alterao e tornou-se:
Recolher | Cdigo Copiar
vazio loop ()
{
static int s_nLastPotValue = 0 ;
static int s_nLastMappedValue = 0 ;

int nCurrentPotValue = analogRead (POT_PIN);
se (abs (nCurrentPotValue - s_nLastPotValue) <POT_THRESHOLD)
retorno ;
s_nLastPotValue = nCurrentPotValue;

/ / int nMappedValue = map (nCurrentPotValue, 0, 1023, 0, 127) / / Mapa do valor
de 0-127
int nMappedValue = map (nCurrentPotValue, 0 , 1002 , 0 , 127 ); / / Mapear o
valor para 0 -127
se (nMappedValue> 127 )
nMappedValue = 127 ;
se (nMappedValue == s_nLastMappedValue)
retorno ;
s_nLastMappedValue = nMappedValue;

MidiVolume (MIDI_CHANNEL, nMappedValue);
}
SysExPedal
Algumas mensagens MIDI, como o MIDI Note On / Off comando eo comando de mudana
de programa so especficas, fechado, e estritamente definido. No entanto fabrica
necessrio um mecanismo para transferir dados personalizados a partir de um dispositivo
para outro, de modo que o open-ended System Exclusive (SysEx) mensagem foi adicionado
especificao MIDI. Uma mensagem SysEx comea com 0xF0 e termina com
0xF7. Tipicamente, o formato dentro destes marcadores a seguinte:
Recolher | Cdigo Copiar
0xF0 - SysEx incio
xx - Fabricante ID
xx - Modelo ID
xx - canal MIDI
xx - dados 1
xx - de dados 2
...
xx - dados N
0xF7 - SysEx final
... Mas o formato deixada para o fabricante para definir. Como eu mencionei no incio
deste artigo, toda a razo para este projeto e entrar em programao de hardware que eu
tenho um processador de efeitos que no responde s mensagens MIDI CC, mas no
respondeu s mensagens SysEx. Migrando do envio de mensagens de CC para o envio de
mensagens SysEx muito para a frente. Se voc comparar o esboo SysExPedal com o
esboo VolumePedal, voc vai ver que os dois esboos so quase
idnticos. Onde MidiVolume () foi chamado quando o potencimetro mudou
agora SendSysEx () :
Recolher | Cdigo Copiar
vazio SendSysEx (canal byte, o volume de bytes)
{
# Ifdef DEBUG
Serial.println (volume, DEC);
# Else
SerialOutput (0xF0); / / SysEx comear
SerialOutput (0x00); / / Fabricante 0
SerialOutput (0x01); / / Modelo 1
SerialOutput (canal); / / MIDI
end
# endif
}
O que est aqui apresentada um exemplo de um dispositivo ficcional. Uma vez que o
formato de uma mensagem SysEx exclusivo para um dispositivo especfico (e no meu
caso, um patch especfico), eu decidi apenas postar o esboo cru do que uma mensagem
SysEx seria semelhante.
Concluso
Isso traz tona o terceiro artigo e conclui minha srie sobre a plataforma de hardware
Arduino. Ns fomos de ligar um LED simples para o desenvolvimento de um produto em
pleno funcionamento. Espero que voc ser capaz de tomar algumas das idias aqui
apresentadas e construir seus prprios dispositivos exclusivos com base em um
microcontrolador Arduino.
Histria
16

de julho de 2009: ps inicial


16

de julho de 2009: Artigo actualizado


Licena
Este artigo, juntamente com qualquer cdigo-fonte associado e arquivos, est licenciado
sob a licena de cdigo Projeto Open (CPOL)
Sobre o autor

jeffb42
Software Developer
Estados Unidos
Em poucas palavras, o meu forte o Windows, Macintosh e desenvolvimento multi-
plataforma, e os meus interesses esto em UI, processamento de imagem, e
desenvolvimento de aplicaes MIDI.