Este documento descreve como construir um pedal de volume MIDI usando um microcontrolador Arduino. Inicialmente, o autor construiu um metrônomo usando um potenciômetro para controlar o tempo, mas enfrentou problemas com valores flutuantes. Posteriormente, ele adicionou código para mapear valores do potenciômetro para uma faixa e verificar contra valores anteriores para filtrar ruídos. Isso permitiu que o potenciômetro controlasse com sucesso o tempo do metrônomo. O autor, em seguida, pretende aplicar essa abordagem para constru
Este documento descreve como construir um pedal de volume MIDI usando um microcontrolador Arduino. Inicialmente, o autor construiu um metrônomo usando um potenciômetro para controlar o tempo, mas enfrentou problemas com valores flutuantes. Posteriormente, ele adicionou código para mapear valores do potenciômetro para uma faixa e verificar contra valores anteriores para filtrar ruídos. Isso permitiu que o potenciômetro controlasse com sucesso o tempo do metrônomo. O autor, em seguida, pretende aplicar essa abordagem para constru
Este documento descreve como construir um pedal de volume MIDI usando um microcontrolador Arduino. Inicialmente, o autor construiu um metrônomo usando um potenciômetro para controlar o tempo, mas enfrentou problemas com valores flutuantes. Posteriormente, ele adicionou código para mapear valores do potenciômetro para uma faixa e verificar contra valores anteriores para filtrar ruídos. Isso permitiu que o potenciômetro controlasse com sucesso o tempo do metrônomo. O autor, em seguida, pretende aplicar essa abordagem para constru
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.