Handmades

Pessoal, boa tarde...

Estou a um tempo matutando a idéia de criar um looper, o problema é que não quero um looper de 60 ou 120 segundos, mas um como o RC-2 da Boss, no entanto um pouco melhorado. Andei vendo várias coisas na net e vi um projeto que me interessou: http://arduino-guitarlooper.blogspot.com.br/2009/10/introduction-here-how-to-produce-small.html

Partindo daí, vi que era possível ter um audio bacana (e não um midi tosco) com o arduino e comecei a viajar na idéia:

Arduíno + SD + Tela =  super looper: http://www.ebay.com/itm/SainSmart-3-2-TFT-LCD-Module-Touch-Panel-PCB-adapter-SD-Reader-for-Arduino-2560-/251095556218?pt=LH_DefaultDomain_0&hash=item3a7676207a


Alguém tem conhecimento suficiente no arduino para me tirar umas dúvidas?

Quero que assim que ele acabar de gravar, ele coloque na tela o tempo da gravação, faixa e a bateria utilizada, quero que ele inicie imediatamente após acabar de gravar, mas não sei se ele vai conseguir, porque vi que a memória dele é bem limitada. Deixa eu explanar a idéia:

No SD eu teria 3 pastas inicialmente: Drums , libs e tracks

Com controles eu escolheria qual o arquivo de bateria ele iria reproduzir, qual o tempo de reprodução, se queria ativar metrônomo ou não (caso não queira bateria) e qual a faixa que eu utilizaria (pensei em deixar fixo em até 30 faixas).

Ele tocaria a bateria ou metrônomo na medida em que também gravava, ele suportaria isso?
Após pisar em Stop, ele iria gravar em um arquivo de textos as variáveis de quais as tracks estariam gravadas, quais eram os parâmetros de cada música como tempo , velocidade, metrônomo e coisas do tipo.
Assim que ele gravasse, ele iria reproduzir o som, permitindo alterar a velocidade, tipo de bateria, ativar ou desativar metrônomo, volume de bateria, volume da música (que já estaria sendo executada).


Acham que ele faria isso? Pergunto isso porque vi que existe agora um sistema operacional para ele, inclusive e virou até palm:

http://www.skewworks.com/pyxis/

Eles tem até plataforma de desenvolvimento e funciona com touch screen (que eu não iria usar tanto assim).

Acho que você precisaria usar um DSP (digital signal processor). Um arduino é apenas um microcontrolador AVR (ATMEGA) numa placa com o hardware mínimo pra funcionar e soquetes para I/O.  Não sei se a velocidade dele é suficiente pra processar sinais analógicos digitalizados e gravar os arquivos e depois reproduzi-los sem um conversor DA.  No projeto que você postou, eu entendi que ele apenas controla os outros equipamentos.

Pra aprender sobre o Arduino, seus diversos modelos e como usá-lo, um bom livro:  Arduino Internals - Dale Wheat.

O que me fez pensar no projeto foi essa gravação que achei o som até aceitável (mesmo considerando que houve perda com microfone da câmera e etc).

http://www.youtube.com/watch?v=C5Pd2MAwsBI

Pelo que eu entendi lendo a página do projeto mostrado no video o pedal seria apenas um controlador, o som seria processado no computador.

É o que eu entendi também!

Também!!!

Sim, mas a idéia seria utilizar o cartão de memória para armazenar os dados de áudio (inclusive bateria) e utilizar as bibliotecas de audio com o shield audio do arduino.

http://arduino.cc/blog/category/audio/


Shild:

http://hackedgadgets.com/wp-content/2/arduino_voice_shield.jpg


Alguém conhece bem o arduíno e saberia dizer se dava para fazer isso? Meu objetivo era fazer algo como o Looper da line6, onde você tem um cartão externo e apenas troca o cartão, arquiva as músicas, etc... nada tão preso como o RC-2 e afins.

Ou o arduino e seus módulos ainda assim não seriam capazes de fazer algo assim?

Penso que você mesmo possa responder essa pergunta. Utilize um ADC do Arduino para uma entrada de sinal analógico amplificado e um conversor DAC em uma porta disponível (há métodos simples de conversores pela net). Faça um programa que converta o sinal analógico em digital e envia o dado para a saída da porta onde está o DAC, grave o sinal analógico que sai do DAC (veja a possibilidade de utilizar um atenuador) no Arduino e verifique a qualidade.

Com o Arduino é possível fazer a gravação em cartões SD.

PS.: Procure o Datasheet do Atmega328, ele informa as limitações do ADC.

Melhor do que os shields do arduino são os módulos de mp3, como por exemplo o TDR025, da Tenda Electronics ...
São 100% compatíveis com o Arduino, e dá pra fazer muita coisa, como gravar, reproduzir, e escolher a faixa desejada para a reprodução, tudo isso com comunicação serial entre atmega e módulo. Resta saber se a qualidade de gravação seria legal para nossa aplicação.

Então Dexter, este que é o lance. Nunca nem peguei na placa do Arduino. Vi nas especificações que a memória dele é relativamente pequena se comparado aos programas que faço aqui, mas se tratando de c++, assembler, acho que dá pra fazer muita coisa com 240kb de espaço. Mas vi que tem memória interna pequena e outras limitações e o que eu gostaria mesmo era de comprar o que realmente desse para trabalhar. Já pensou eu comprar os módulos errados e investir $100,00 e não prestar para nada? Já eram as válvulas de um amp pequeno.


Felfoldi
Eu estava olhando essa placa, mas não manjo nada ainda de Arduino. Eu ia me aventurar um pouco com ele e estava olhando essa placa https://shop.ruggedcircuits.com/index.php?main_page=product_info&cPath=4&products_id=58

Serviria? Ou olhar agora essa TDR025.

Não precisaria ser qualidade de Studio (inicialmente), mas que agente tivesse um som compactado que também não soasse como um midi ou um telefone tocando algo, entende?

Algo que não te fizesse passar vergonha num ensaio mostrando: Olha o que eu gravei aqui...

Com este shield a um processamento de áudio de 44,1 kHz dá pra fazer coisa "pra Caramba"! Se estiver na dúvida, procure aprender mais sobre o Arduino até se sentir seguro em adquirir o shield sugerido. O próprio fabricante sugere trechos de código para para programação de algumas funções.

Então existe a possibilidade de se fazer um looper com o arduíno e um shild desses com o cartão de memória, correto? Vou estudar! Pretendo construir um ou iniciar o projeto até o meu aniversário (julho do ano seguinte), sendo assim, quando eu pagar minhas dívidas (não todas porque senão não compro nunca _), vou comprar o arduíno e o módulo. Será que comprando eles no ebay fica retido? Sei que o melhor pedido de compras é em dezembro porque em dezembro e janeiro o pessoal daqui tá de férias e passa mais fácil, já que o volume é maior. Mas terei que esperar.

Se alguém que tiver o arduíno e os módulos quiser já conversar para agente seguir uma linha, posso ajudar com a programação, idéia, estruturação de agora. Só os testes que não dariam (a menos que haja um simulador. Existe?). Fala por PVT, ok?

Abraços e até daqui a um tempinho.

Tenho um módulo TDB380, foi justamente para fazer estes experimentos... Mas ele só reproduz, não grava. Mas é da mesma familia do outro TDB, é só mandar um código serial na porta dele que ele faz o que pede, não tem mistério; se pretende iniciar com o arduino, sugiro que comece com experimentos mais simples para evitar de queimar o módulo ou o próprio arduino. Outra dica é fazer seu próprio arduino , como no link abaixo :
http://arduino.cc/en/Main/ArduinoBoardSerialSingleSided3

A preocupação que tenho com esses módulos seria a qualidade de gravação e também a velocidade com que o audio começa a ser reproduzido... Como faz um tempinho que já brinquei com esse módulo, não me lembro se tinha um "delay" antes da reprodução

Estou começando a programar no simulador. Assim saberei se vou queimar ou não. _

Pretendo fazer ele ler e gravar e vou estudar mais um pouco, mas pelo que olhei, aquele módulo permite gravar (a biblioteca dele pelo menos tem a função write() ).

Meu medo é que o código fique tão grande que não dê para colocar dentro do arduino. Por isso que queria ajuda dos colegas. Vou utilizar no projeto desde o início a interface ADC -DAC , o cartão SD e o visor. Lógico que vou começar a passos curtos, mas quero já que no primeiro momento eu tenha como escolher o que fazer (no visor mostra opção de gravar ou apagar o que foi tocado), reduzir tempo do metrônomo ou bateria e tempo restante para gravação(este será bem depois). também quero ver se há possibilidade de mixar a reprodução, coisa que já acho que ele não seja capaz... mas se alguém souber.... A mixagem vai ser para tocar a bateria no tempo que foi configurado junto com o arquivo que foi gravado em mp3 ou wav da guitarra, baixo e afins...

---

-----

---

Só duas coisas que esqueci de perguntar...

1- O ATMega precisa ser gravado antes em PIC ou na hora que coloco ele no pc, a gravação é justamente o bootloader e o código que vou enviar?

2 - Outra coisa. Utilizo um notebook desses novos. Não tem mais porta serial e nem paralela. Será que com aqueles adaptadores USB/Serial ele funcionaria? Gostei dessa de fazer o arduino, mas acho que ele não vai aguentar tudo isso que foi colocado. Primeiro pela quantidades de pinos de entrada e saída. Como são dois shilds, acho que não vai dar... segundo pelo tamanho que o código vai ficar. Mas mesmo assim estou pensando em fazer e ir aprendendo natoralmente... _

De qualquer forma, estou com simuladores aqui.

Eu, particularmente, não utilizo o Arduíno em si, apenas uso a interface de programação dele.
Trabalho com projetos sempre com STAND-ALONE (seria o mínimo possivel, o Atmega, cristal,uns 3 ou 4 capacitores e o regulador 7805 ). Isso reduz o espaço físico na placa, reduz o custo (já que um arduino não é nada barato).
A única coisa que você precisa é de um GRAVADOR (já adianto que utilizando adaptadores de USB>SERIAL não funciona legal).Você pode comprar um , ou faze-lo. Eu fiz um versão serial, funciona 100% , quando eu achar o link eu posto aqui. Existem alguns q são USB também.
Ai, utilizo a interface do arduino e após a conclusão do projeto, retiro o arquivo .HEX , abro com o programa chamado Ponyprog, e gravo o arquivo no Atmega. Depois disso, está feito, é só correr pro abraço.

Com esse processo acima, você 'esquece' do chamado bootloader, já que você não gravará o código através da interface do arduino, e sim através do ponyprog .

A interface do arduino comporta o Atmega8 , Atmega168 e Atmega328, ai você escolhe de acordo com o tamanho do seu código fonte.
Quanto ao visor, a interface do arduino tem uma biblioteca muito facil de utilizar, tudo pronto para uso.

Se utilizar aqueles shields tipo os TDB , as unicas ligaçoes que fará no arduino (ou placa stand alone) será entre TX e RX, já que eles se comunicam via serial, já que até as funções "play, stop, rec" podem ser controladas por este metodo.

Estou quase pegando a causa para fazer  :D fiquei com vontade do projeto.

_ quando vi as possibilidades que o arduíno fornece, vi que seria uma boa saída. Só fiquei com receio do tamanho do arquivo, espaço de armazenamento desses pequenos (32k) e das ligações.

Esse serial possui RX e Tx? Não olhei o manual e esquema p q (moderador, peço que me suspenda do fórum) estou no trabalho.

Se funcionar, vou acabar fazendo esse para testar.

Manda o esquema desse super reduzido que você tem. O que peguei dos posts anteriores, tem mais componentes e a placa achei mais chatinha de ser feita. As impressoras daqui a laser estão descascando o tonner e tá muito ruim de fazer.

No próprio site do arduino tem o esquema dele no formato PDF e Eagle.

Adquira o AT328 grave o bootloader do arduino (alguns lugares já vendem o AT328 com o bootloader) liga o TX e RX no PC através de um max232 e alimente o circuito (AT328 e max 232) com 5V regulado, não tem mistério. Na programação cada pino é associado a um número, pelo esquema e layout dá pra descobrir facilmente o pino do AT328 que é utilizado.

Até mais.

Na verdade eu comprei o Arduino mega 2560. Pelas minhas contas, esse projeto teria que ter bastante espaço, memória ram adicional para escrever os dados convertidos pelo ADC e bastante pinos disponíveis.

Assim que chegar, poderia tirar umas dúvidas com você e produzirmos juntos o material?

Designer  não seria isso aqui que vc quer?

http://ruggedcircuits.com/html/rugged_audio_shield.html (http://ruggedcircuits.com/html/rugged_audio_shield.html)

foi exatamente esse que andei pesquisando, mas quando vi estava em falta (e parece que ainda está). Esse foi o único pelo que vi que dá para fazer tudo quanto é coisa com relação ao looper. Salvo engano, o módulo de memória ram adicional eles também fabricam (que será necessário para gravar com qualidade alguma coisa). Fiquei de olho nos módulos rugged porque são compatíveis com o arduino. Acabei de adaptar uma tela LCD de celular para colocar no arduino qnd chegar. Farei algumas funções básicas já com o lcd , farei também os botões e funções.

Alguem sabe como fazer para executar uma função inclusa em arquivo externo e executada por outra função (cascata)?

Vou citar um exemplo.

Supondo que quero personalizar meus comandos para facilitar a interface. Pegarei uma biblioteca Glcd e criarei menus dentro de menus por um único comando e quando chegar nos resultados, quero que execute a função com o mesmo nome do submenu. EX:

meu comando seria:

addGroupMenu("Menu Principal",2,"Mostrar Versão","versao", "Voltar","voltar")

Ele criaria na tela o botão menu principal, onde haveriam dois submenus chamados Versão, onde ao escolher ele executaria a função versão e a voltar que executaria a função voltar para a tela anterior.


Faço muito isso em outras coisas que programo aqui e aparentemente fica redundante, mas isso fica muito fácil de organizar as bibliotecas e serparar todas as funções e leitura do código, tendo no código principal praticamente linhas de texto como se fosse uma redação. Fica muito fácil de trabalhar em grupo com esse método e muito fácil de dar manutenção depois.


Alguem experiente teria como fazer um código simples aqui só pra teste?

existem coisas que fico sem saber e n acho no google como por exemplo:


var i=0: Number

function mostreValores(retornoPrint:String):void{

   return(retornoPrint);
   print(retornoPrint);

}


for (i=0;i<10;i++){

  mostreValores("valor"+i)= i

}



Isso eu fiz a grosso modo e não tem nada haver com linguagem de arduino ok? É apenas para entendimento.


Em algumas linguagens, ele concatena e entende que a função receberá o valor de retorno com a concatenação, como exemplo. Se fosse código de arduino, teria que colocar o barecode, declarar fora, etc....


Outra coisa... caso consiga algum avanço em tempo hábil, os colegas ajudariam a montar o projeto ?

Cara... eu não consegui entender completamente o que você quis dizer.... eu nunca programei pic.. não sei das limitações dele... mas de C++ eu entendo... e não entendi o que você ta querendo.... tenta codificar em c++o que vc quer ai ja serve de modelo.. dai talvez eu entenda o que você precisa. se eu puder te ajudo com certeza... abraço!

Vou usar um exemplo usado no flash.Vamos supor que eu queira chamar uma função. Vou colocar de maneira bem arcaica só como exemplo, já que neste caso não quero entrar em condicionais e matrizes, ok?


Se tenho um conjunto de funções... lerBT1 , apagarLed1 ,acender led1 ,lerBT2 , apagarLed2 ,acender led2 ... e assim por diante, ok?

ai eu faço um for para executar isso um de cada vez até o número 10.

for(i=1;i<=10;i++){

// No flash eu posso chamar várias coisas apenas concatenando, inclusive funções

      _root["lerBT"+i];
      _root["acender"+i];
      _root["acender"+i];

// Esse foi um exemplo meio tosco, mas vou usar outro com o próprio código do arduino

}



 >>(:

// ARDUINO

int i;
int pino;
int l;

int pins[]= {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26};


void setup() {

   for(int i=0 ; i<54 ; i++){
        pinMode(i,OUTPUT);
       //digitalWrite(i, LOW);

    }



}


void   pulse(int i, int tempo) {
    digitalWrite(i,HIGH);
    delay(tempo);
    digitalWrite(i,LOW);
    delay(tempo);
}


void loop() {
   for(int l=0;l<17;l++){
      pulse(l,100);
   }
}


No caso da linha:

 int pins[]= {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26};



queria colocar apenas que a array pins[] receberia automaticamente o valor pelo for... ou seja, ela estaria dentro de um for com o pins.

Entendeu?

Esse código é verdadeiro e já roda em simulador, mas não consegui fazer como eu faria em outros códigos (PHP, ACTION, Jquery)...

Note também que eu criei uma função pulse para fazer o led ficar em fade in  e out sem precisar ficar redigitando... isso encurta o código, mas vamos supor que eu precise variar rapidamente várias funções e que além do pulse(l,100) eu precise trocar o nome da função apenas no final... pulse1(l,100) , pulse2(l,100), pulse3(l,100) ....

Você quer variar o nome da função que você vai chamar mandando o nome dela como parametro?   

Desculpa brother é q eu não to pegando a ideia talvez por nunca ter programado um pic...

Mas vamos pelo resultado... como se eu fosse programar pra você.... me pede o que voce quer.... tipo....

Ah eu quero entrar no meu apertar isso selecionar aquilo e que aconteça isso...
ou
ah quero poder chamar diferentes funçoes mudando o parametro
ou
quero mandar o nome da função a ser executada bem como seus parametros atravez de um preset selecionado no menu.....

etc....   acho q não to ajudando muito... mas é que sem entender o que você precisa de fato! fica dificil rsrsrsr... abraço!

 Talvez eu não tenha entendido bem, mas e se ela fosse uma variável estática, "static int" ? Assim ela não seria destruída no retorno da função... Seria isso?

 Isso seria o conceito de objeto em C++ correto? Você cria a classe "pulse" e vai criando os objetos a partir dela. Bom, em C acho que não tem jeito mesmo, o máximo que conseguimos fazer é organizar as variáveis em structs.
 Mas há mesmo necessidade de criar várias funções "pulse" ?

 Pelo que eu entendi você quer usar vários pinos do microcontrolador ao mesmo tempo, porém dentro da sua função você tem os "delays", dai encavalaria tudo pois enquanto você não retornasse da função você não poderia fazer mais nada... É isso?

 Um abraço

Eduardo

Os dois estão certos.

* Tanto gostaria de saber sobre:

"Você quer variar o nome da função que você vai chamar mandando o nome dela como parametro?"

* Como o caso de Ledod:

"Você cria a classe "pulse" e vai criando os objetos a partir dela. Bom, em C acho que não tem jeito mesmo, o máximo que conseguimos fazer é organizar as variáveis em structs.
 Mas há mesmo necessidade de criar várias funções "pulse" ?"



Ledod, o que quero fazer é criar bibliotecas modificadas usando as já existentes. Você já conhece o Glcd, correto? Imagine agora eu ter um único trabalho de fazer uma estrutura de menus e criar tudo que eu quero executando a função final de acordo com o nome do botão.

Nesse exemplo o delay foi usado por conta do projeto, mas nem sempre haverá delay, entende? O mais importante nesse exemplo é de como executar as funções com nomes variados alterando parâmetros.

Veja esse exemplo que coloquei no iníicio:

addGroupMenu("Menu Principal",2,"Mostrar Versão","funcVersao", "Voltar","funcVvoltar")


Nesse caso existiria um objeto na tela (botão) chamado menu principal que ao entrar era um grupo contendo dois itens. Um deles é para mostrar a versão do software. Em seguida era o nome da função que vai ser executado ao entrar no botão Versão, ou seja, entro no menu principal, vejo dois botões. Um é versão e o outro é Voltar. Se escolher Versão, executa a funcVersao(), se escolher Voltar, executa o funcVoltar e iria para a tela inicial por exemplo.


Isso parece bobo, mas não sei como fazer no arduino passando por parâmetro como executar essa função. Outra coisa é que isso vai facilitar porque posso criar uma biblioteca de funções para apenas executar. O projeto seria grandinho e isso vai ajudar a organizar e simplificar a coisa para agente. Seria uma api dentro da própria api, entendem?


Coisas que penso em ter no projeto: Configuração, formatar SD, versão, voltar, metrônomo (depende de configuração), gravar, executar, volumes (depende de configuração), excluir, etc...


Olhei alguns códigos arduino e vi que eles são bem chatinhos de se trabalhar (como o C) e acho o C++ bem evoluído em quase todos os parâmetros que seriam necessário nesse projeto e ai ficou meio complicado, mesmo sendo uma linguagem antiga (depois que aprende a dirigir em carro automático, andar de fusca tunado fica estranho e  até difícil de dominar).

Achei que para mim vir de linguagens orientadas a objeto e que você pode executar várias coisas locando memória e etc... para entrar em uma que vem de uma estrutura de loop ficou meio complicada, ainda mais quando não conheço a linguagem. Se essas coisas não forem possíveis, acho que vou ter que entrar com o tradicional mesmo e isso tornará o projeto mais longo, porém, sei que vai funcionar.

* Acho que essa semana ele chega. A pergunta que quero fazer é: Existe risco de queimar o arduíno de alugma forma além de consumir mais do que ele fornece ou fornecer mais do que ele pode receber de alimentação?

Quero primeiro saber sobre o arduino (já estou baixando coisas e catando livros) para depois projetar e ai sim fazer... Não quero ir programando e ver no que dá, entendem?

Vocês tem github??


* ( perguntas que são importantes para eu pensar em como seria feito o projeto).

 Acho que entendi o que quer fazer!
 Bem eu não conhecia essa library, nunca mexi com o arduino, mas para quem tem curiosidade: http://playground.arduino.cc/uploads/Code/GLCD_Documentation.pdf

 Então, é complicado "voltar" de um C++ para um C, toda a mentalidade/paradoxo de classes e objetos é perdida... Eu acho que é possível sim fazer em C, mas devemos lembrar sempre que o C é uma linguagem estruturada, voltada a funções.

 Ou seja, tente não pensar em objetos e sim em funções e retorno de funções. Por ex, na função de "adcionar um menu", o que você precisaria ? Tente pensar mais no baixo nível do código (é complicado, mas é um bom exercício).


 Para realizar em C essa função teríamos que pensar primeiramente no número máximo de submenus que queremos, pois ai saberíamos quantos parâmetros teríamos que passar para função. Em C não dá para você colocar um parâmetro "a mais" automaticamente, dizer que a partir de certo do ponto da lista de parâmetros, uma será a função e outra a variável. Você precisa declarar isso manualmente.

 Para resolver esse problema acho que teria que organizar o menu como um todo como se fosse uma struct (com cada espaço do menu reservado em uma posição, ou seja, precisa declarar antes quantos são os menus) e a partir dai criar uma função que seta a figura dos menus como um parâmetro dessa struct, e talvez uma flag indicando se é para executar a função. Dai você le o "status" que está a struct (quais os menus, se é para executar a função...) imprime na tela e executa a função de acordo com uma lista pré definida (usando um "switch case" por ex...).

 Acho que teria que ser mais por ai... Devemos lembrar t b m (moderador, peço que me suspenda do fórum) que microcontroladores são bem limitados! Não tem como criar um software totalmente modular com risco de não termos espaço na memória. A menos que você abandone o arduino e parta para um ARM mesmo (a família cortex, e tals) e com isso você rode um SO nele. Mas dai já fugiu da idéia inicial!


 Bem, queimar um microcontrolador devido a software acho impossível... Se o hardware é compatível (pinos de IO ligados corretos, frequência do clock ok, etc) o máximo é travar o programa e consumir alguns mA a mais... Mas nada que possa destruí-lo

Um abraço

Eduardo

Ledod, exatamente isso que eu queria saber. Para mim vai ser realmente um grande exercício, pois para quem está acostumado com uma coisa passar para outra em raciocínio de décadas atrás pode ser bem difícil e espero que eu consiga.

Quanto ao arduino, peguei logo o mega 2560 justamente por causa disso. Ele tem 252k de rom, 4k de boot loader e tem 8k de memória ram, mas existem módulos de memória sram para arduino, salvo engano de até 512k.


O maior problema acredito que seria no caso da leitura e gravação no cartão SD. Existe limite de velocidade e isso é ponto crítico no projeto. Se isso não for possível com arduino, farei com que ele seja um controlador de pedais digital com exibição de repertório para usar no palco _...

Existe algum projeto tipo arduino que use processamento ARM? (com interface, módulos e etc?) Caso exista é interessante saber.

Quanto à GLCD é essa mesma a biblioteca. Ele faz muita coisa, inclusive menu de forma mais direta.

 Arduino com ARM? Acho que não existe...

 Na verdade o Arduino mesmo é só um bootloader e um conjunto de library's e uma IDE para facilitar bastante o desenvolvimento. O hardware mesmo é um microcontrolador com alguns periféricos e só!
 Digamos que eles mastigaram toda a parte chata de mexer com microcontroladores (configurações, como gravar) e deixaram apenas a parte "legal", que é a programação em si.

 Um ARM (pode ser 7 mesmo, os cortex M já são até melhores) é bem mais poderoso, tem funções de debugger in circuit, trace, já é uma arquitetura de 32 bits... Mas não tem tanto suporte quanto um arduino, você precisaria procurar as librarys ou se contentar com as que vem com as IDE's, ou programar na "raça" :D
 

 Espero que consiga! Antes, tente desenhar um diagrama do que você precisa e sempre pensando nas funções e o que é retornado das funções. Use e abuse dos ponteiros!!!


 Um abraço

Eduardo

Vou iniciar com o arduino mesmo... só se ele for extremamente limitado que tentaria mudar. Você manja Ledod? tem alguns exemplos para passar?

Só para mostrar como o arduino tem sido motivo de empolgação de várias coisas, surgiu o Pyxis OS , onde existe até interface de desenvolvimento.

http://www.youtube.com/watch?v=rLh77U9Wslw

Quanto à memória ram, achei esse shild:

http://ruggedcircuits.com/html/megaram.html

 Arduino não tenho experiência nenhuma, nunca utilizei... Fiz alguns programas em C para ARM, nesse quesito posso tentar ajudar!

 Interessante esse SO, já é algo bem mais evoluído! Talvez seja uma idéia legal, como mostrado no vídeo, afinal, o que você precisa é muito mais uma interface com usuário do que um simples microcontrolador executando um código em loop.

 Qualquer coisa só perguntar!

 Um abraço

 Eduardo

Então, o arduino chegou. Primeira impressão é que é legal, mas quero ver rendimento. Vou comprar agora o módulo de áudio e sd.

Pelo que vejo muita gente usa o Uno. Como eu vou utilizar muitas coisas, optei por usar logo o arduino mega (padrão diferente), já que ele tem 8k de sdram, 4k de eprom, onde usarei para guardar configurações básicas e alguns dados e também 256 de eprom, onde 8k são rom. Algum problema?

Pessoal, Primeiro obrigado pela paciência.

Vamos nos aventurar em um projeto? Ledod mais do que ninguém sabe dos projetos que fiz _ principalmente com baterias de notebook _

Bom, penso em colocar no meu projeto um Pedalboard totalmente digital. Que tal agente fazer o pedalboard controlado pelo Arduino? Vi que ele não tem condições (processamento e memória ram) de ser um looper com qualidade aceitável, mas andei vendo e ele tem como ser voltímetro e chaveador, então pensei nele ser um switcher. O que acham?  Ele teria todos os pedais nele, no final do pedalboard (parte de trás) , teríamos um LCD informando os bancos, pedais ligados e a situação da bateria ou rede elétrica.

Vamos começar?  Alguém para ajudar?

Caso concordem, estarei colocando os links aqui que já achei que ajudariam no projeto.

Abraços.

É um desejo antigo meu:
Ter pedais analógicos controlados digitalmente.

Ok, Vou estudar o caso para desenvolver. Quem quiser ajudar, estou esperando em PVT

Mas tenho que ser sincero: não tenho nehum conhecimento nessa área.

Nascimento do código:

#define RELAY_PIN 3 // Relay Canal 1 - Armar direto ou não

#define RELAY_PIN 4 // Relay Canal 2 - Armar direto ou não



#define RELAY_PIN 5 // Relay Canal 3 - Armar direto ou não

#define RELAY_PIN 6// Relay Canal 4 - Armar direto ou não



#define RELAY_PIN 7 // Relay Canal 5 - Armar direto ou não

#define RELAY_PIN 8// Relay Canal 6 - Armar direto ou não



#define RELAY_PIN 9

#define READ_PIN 10 // Pino de controle de energia



#define RELAY_PIN 11// Relay para desarmar o carregador automaticamente da rede elétrica. Relacionado ao pino de leitura.PIN 10

#define RELAY_PIN 12// SERIE/PARALELO - Controle de energia (Ajusta o sistema para 12v paralelos com alta amperagem e 24 v para final de carga - desarmando com aproximadamente 12v para não zerar a bateria , parâmetro configurável); Relacionado ao pino de leitura. Relacionado ao pino de leitura PIN 10.

int i=3;



void setup()

{

for(i=3; i<13; i++){

   pinMode( i, OUTPUT );

  }

  pinMode(READ_PIN, INPUT);

  Serial.begin(9600); // open serial

  Serial.println("Aperte 1 para ativar o relay 1, 2 para ativar o 2 ...5 para o canal 5 e barra de espaço para o canal do amplificador - relay mode on/off");

}







void loop()

{

  static int relayVal = 0;

  int cmd;

 

  while (Serial.available() > 0)

  {

       cmd = Serial.read();

      

       switch (cmd)

       {

       case '1':

      {

        relayVal ^= 1; // xor current value with 1 (causes value to toggle)

       

        if (relayVal){

         digitalWrite(3, HIGH);

         Serial.println("Relay 3 on");

         

        }else if(!relayVal)

            digitalWrite(3, LOW);

         Serial.println("Relay 3 off");

         

        break;

      }

      

       case '2':

      {

        relayVal ^= 2; // xor current value with 2 (causes value to toggle)

       

        if (relayVal){

          digitalWrite(4, HIGH);

          Serial.println("Relay 4 on");



        }else if(!relayVal)

          digitalWrite(4, LOW);

          Serial.println("Relay 4 off");



        break;

      }

      

       case '3':

      {

        relayVal ^= 3; // xor current value with 2 (causes value to toggle)

       

        if (relayVal){

          digitalWrite(5, HIGH);

          Serial.println("Relay 5 on");



        }else if(!relayVal)

       

          Serial.println("Relay 5 off");

        break;

      }

      

       default:

      {

        Serial.println("Aperte a barra de espaço para relay on/off");

      }

      

   }

   

   }

}

Então Ledod, estava pensando aqui em casa e é realmente mais difícil de se acostumar, mas eu estou até indo bem. Assim que acabar, mostro o que fiz. Achei meio complicado não utilizar o delay e ter que fazer funções com diferença de tempo e millis, mas ficou muito bom.

Você tem como me ajudar com algumas coisas Ledod? Sei que não tem experiência com Arduino, mas percebi que as bibliotecas são uma mistura de C e C++, como não manjo nenhum dos dois, estou num emparse...
Estou fazendo uma controladora de pedais com o Arduino com várias funções e recursos que vão ajudar o músico, porém estou com um problema na leitura de variáveis de um arquivo no cartão SD.

Vi várias pessoas fazendo isso, mas nenhuma das "80 páginas" que tentei mexer no código serviram para mim.

Vou colocar o código abaixo da resposta para Tiarlei Crist.

Gostaria de fazer uma função do tipo:  readSD("arquivo.cfg",linha). Ele pegaria o valor de uma configuração como LCD=1 e criaria uma variável (poderia ser com o mesmo nome) e colocaria o valor dentro dela.


É o que estou tentando e acho que vou conseguir meu velho, porém terá que ser com o Arduino mega pela disponibilidade de pinos. O uno é muito limitado para o que quero fazer e além de poucas portas, tem apenas 30kb de memória. Até o momento todo o código está com 22k, no entanto só vou colocar aqui um pedaço para não ficar tão complexo.


Código com a biblioteca tinyFat:

// Demo_readLn (C)2011 Henning Karlsen
// web: http://www.henningkarlsen.com/electronics
//
// This program is a demo of the readLn()-function.
//
// This demo will open a textfile named 'TEXTFILE.TXT'
// and display its contents in the Serial Monitor.
//
// SD card must be connected to the SPI port of your Arduino.
//
// Remember to select 115200 baud in the Serial Monitor.
//

#include <tinyFAT.h>
#include <avr/pgmspace.h>
char LCD;
byte res;
word result;
char textBuffer[2501];
char *verboseError(byte err)
{
   switch (err)
   {
   case ERROR_MBR_READ_ERROR:
      return "Error reading MBR";
      break;
   case ERROR_MBR_SIGNATURE:
      return "MBR Signature error";
      break;
   case ERROR_MBR_INVALID_FS:
      return "Unsupported filesystem";
      break;
   case ERROR_BOOTSEC_READ_ERROR:
      return "Error reading Boot Sector";
      break;
   case ERROR_BOOTSEC_SIGNATURE:
      return "Boot Sector Signature error";
      break;
   default:
      return "Unknown error";
      break;
   }
}

void setup() {
  // Initialize serial communication at 115200 baud
  Serial.begin(115200);
  Serial.println();
  // Initialize tinyFAT
  // You might need to select a lower speed than the default SPISPEED_HIGH
  res=file.initFAT();
  if (res!=NO_ERROR)
  {
    Serial.print("***** ERROR: ");
    Serial.println(verboseError(res));
    while (true) {};
  }

  Serial.println("This demo will display a textfile called 'TEXTFILE.TXT'");
  Serial.println();
  Serial.println("***** Send any character to start *****");
  while (!Serial.available()) {};
  Serial.flush();
  Serial.println();
  Serial.println();
 
  if (file.exists("data.cfg"))
  { 
    res=file.openFile("data.cfg", FILEMODE_TEXT_READ);
    if (res==NO_ERROR)
    {
      result=0;
      while ((result!=EOF) and (result!=FILE_IS_EMPTY))
      {
        result=file.readLn(textBuffer, 2500);
       
        if (result!=FILE_IS_EMPTY)
        {
          if (result==BUFFER_OVERFLOW)
            Serial.print(textBuffer);
          else
           
            Serial.print(textBuffer);
           

        }
        else
          Serial.println("** ERROR: File is empty...");
      }
      Serial.println();
      file.closeFile();
    }
    else
    {
      switch(res)
      {
        case ERROR_ANOTHER_FILE_OPEN:
          Serial.println("** ERROR: Another file is already open...");
          break;
        default:
          Serial.print("** ERROR: ");
          Serial.println(res, HEX);
          break;
      }
    }
  }
  else
  Serial.println("** ERROR: 'TEXTFILE.TXT' does not exist...");
  Serial.println();
  Serial.println("***** All done... *****");
 
} 

void loop()
{
}



Segundo a página da lib file.readLn(textBuffer, 2500);    deveria retornar a próxima linha, mas não é o caso aqui. Não entendi como funciona.

Página da lib: http://henningkarlsen.com/electronics/library.php?id=37

Parabêns pelo avanço designermx2!

Seria realmente fantástico poder criar bancos de pedais analógicos e alternar estes bancos como se queira.

Até mais.

Valeu Tiarlei Crist, obrigado pelo incentivo.

Ledod, acho que vou colocar o loop em uma versão mais avançada do projeto, porque preciso de uma memória ram que não acho em canto nenhum. Mas estou começando a entender essa programação do Arduino. Realmente é algo bem chato por não ter uma orientação a objeto no desenvolvimento, mas as bibliotecas podem por serem C++ (não conheço, mas estou estudando).

Gubterra, você que manja, gostaria de ajudar no projeto? Estarei apenas colocando o Hex aqui porque não quero que alguma empresa ou Handmade que não contribui com o pessoal de forma alguma, apenas se exibem, peguem o projeto e ganhem com o código que deu trabalho de montar... Mas aceito ajudas pontuais e "privadas".

Quero publicar apenas o hex.


Hoje o projeto usa um lcd de 20x2 (vinte colunas e duas linhas).

Tem um metrônomo configurável.

Fiz um shild de cartão SD de até 2gb que usam alguns resistores apenas e sucata de notebook (o socket)

Uma placa que servirá de "protoboard" que encaixa no arduino mega como um shild. Já tem os locais para soldar o lcd... botões, sd, etc... (percisa ser melhorado por profissionais da área que aqui sei que tem de sobra).

O falante é de algum telefone. Usei piezo por conta da altura do falante. Durante um ensaio pode-se ouvir o metrônomo (função que deu bastante trabalho e dará mais um pouco daqui a um tempo). Por não poder usar delay para setar o tempo do metrônomo, tive que "inventar" um delay que processe o tempo de batida de acordo com o loop sem gerar atrasos por conta do código. Até o momento está funcionando perfeitamente e comparei com metrônomo real.

O LCD tem alguns funções específicas que consegui uns códigos na net e dei uma melhorada boa.

As letras são grandes para indicar o banco e o número. Fiz até o H, mas existem os códigos até a letra 5.

Por configuração será setado quantos presets deseja usar. ou seja.. vai de A1 até H4 (menor configuração que usam 6 botões, onde dois são de up/down dos bancos e 4 de presets) ou de A1 até H8 , onde teremos nesse caso 8 presets. Caso queiram, pode ir até Z, mas será numa segunda versão e acho que ninguém usará isso tudo, mas de qualquer forma o LCD vai suportar.

A forma de chamar as coisas está bem simples, tipo:

showBigChar('B',0);
showBigNum(3,4);

Nesse caso aparece B3 em tamanho grande e o resto em tamanho normal.

Onde teremos o Caracter "B" Ocupando as duas linhas  e quatro colunas (tamanho grande) e em seguida temos o Número 3 iniciando do ponto 5 (deixei um espaço padrão).

clearBigChar(0); onde limpa 4 colunas começando do ponto/coluna zero, isso limpa caracteres grandes facilitando e reduzindo o código no loop.

metronome(0,0), onde nesse modo está desligado e aparece OFF no visor;
metronome(80,0), onde nesse modo está mostrando  um metrônomo visual no LCD setado em 80bpm com blocos alternando de um lado para o outro, porém sem som. Bom para estudar a noite quando a patroa está dormindo (fiz esse pensando em mim, já que faço isso com a guitar desligada e já incomoda).
metronome(300,10); agora o metrônomo está setádo em 300bpm, com uma nota que multiplica 250x10. Não sei informar a nota pois vi a função e não me dediquei muito a entender. 10 é estremamente grave e quase inaudível, 1000 é um beep tipo de computador, setei 250 como padrão e você coloca o fator de multiplicação no lado direito da função e o valor do parâmetro(neste caso é 10) é multiplicado por 250, ou seja... 4x250= 1000, 10x250 = 2500. Quanto mais alto, mais distante se consegue ouvir e isso configura.

Os valores estão no cartão SD como XML, fácil de editar e penso depois em ter algum programa de interface de configuração para facilitar o uso dela via usb e programar tudo por computador (mas será bem pra frente).

Também tem o reconhecimento de pressão de botões, tipo... escolhe x botão apertado por x tempo e executa x função... isso vai servir para configurar as coisas mas ainda não aprofundei por falta de grana para botão e tempo também, já que agora começou uma reforma lá em casa e estou sem nenhum espaço nem para pintar um pedal, quanto mais outras coisas.


Hoje o que falta de importante mesmo e que ainda dará algum trabalho é a gravação de linhas específicas no cartão SD das configurações que o usuário escolher e o menu de configuração juntando os valores em menus... que julgo ser simples, só não fiz logo porque não tinha os botões... agora não tenho como fazer...
Também falta o controle, mas como disse, isso depende de botões. O grosso e mais complicado acho que já está ai... o SD também deu um certo trabalho, mas já lê os valores. Tem uns três meses que acho que tá pronto, mas como não estou com tempo e nem previsão, não quero deixar a galera aqui esperando...

Algum candidato a ajudar e se comprometer em devolver o código com as atualizações para juntos publicarmos o HEX pronto para o pessoal?


Tudo está comentado (acho que tem tanto comentário quanto código). Salvo engano, todas as linhas de código estão comentadas, se faltar é uma ou outra parte que posso ter julgado ser simples.... mas até variáveis comentei...

Não sou programador em C, mas acho que não está com erros não, pelo menos não com erros graves.

Candidatos?