Arduino IDE 1.6 disponibilizada

Depois de dois anos em desenvolvimento a nova Arduino IDE foi disponibilizada! =D

Arduino 1.6

As principais funcionalidades dessa nova versão são:

  • Suporte para múltiplas plataformas
  • Placas são detectadas e listadas no menu “lista de portas”, juntamente com a porta serial
  • Drivers e IDE são agora assinados para Windows e OSX
  • Melhoria da velocidade de compilação
  • Autosave quando compilar/upload um scketch
  • Um monte de melhorias do monitor serial
  • Localizar/substituir em múltiplas abas
  • Lotes aperfeiçoados de bibliotecas de API Arduino (String, Serial, Print, etc.)
  • Ferramentas e toolchains atualizadas (avr-gcc, arm-gcc, avrdude, bossac)
  • Interface de linha de comando
  • IDE reporta tanto tamanho do sketch e uso de memória RAM estática
  • Editor exibe números de linha
  • Menus de rolagem quando muitas entradas são listadas
  • Upload via rede (Yun)
  • HardwareSerial foi melhorada
  • Melhorias de estabilidade e desempenho no USB
  • Biblioteca SPI agora suporta “operações” para uma melhor interoperabilidade ao usar vários dispositivos de SPI ao mesmo tempo
  • Melhor suporte a hardware de terceiros com arquivos de configuração (platform.txt e boards.txt)
  • Submenus com configuração para placas agora pode ser definidos
  • Correção para problemas de upload de Leonardo, Micro e Yun.
  • Bibliotecas preparadas para o Arduino foram melhorados e bugs removidos: Bridge, TFT, Bridge, TFT, Ethernet, Robot_Control, SoftwareSerial, GSM
  • Um monte de pequenos bugs da interface do usuário foram corrigidos

Você pode baixar o Arduino IDE nesse link: http://arduino.cc/en/Main/Software

 

Fonte: http://blog.arduino.cc/2015/02/09/arduino-ide-1-6-is-released-download-it-now/

Procurando por gems?

Uma boa dica para buscar gems para consumir é o site: https://www.ruby-toolbox.com nele você consegue buscar uma determinada gem, se a mesma estiver categorizada, você consegue comparar com outras gems similares, saber qual é a mais utilizada pelos desenvolvedores, quais são suas dependências e o mais importante, qual o endereço do projeto. Super importante para você entender quais foram os últimos commits, quem são os desenvolvedores, quais issues estão abertas e por aí vai!

ruby-toolbox-1 ruby-toolbox-2

Bundler – bundle config e mais algumas coisas

O Bundler é para o mundo do Ruby o que o Ant é para o mundo do Java, ou npm para o mundo do node ou até mesmo o composer tenta ser para o mundo do PHP.

É uma ferramenta de muita utilidade para qualquer projeto, desde os menores e principalmente aos maiores, independente de framework ou qualquer outra coisa.

Pra você utilizado-lo é necessário instalar, utilizando o comando abaixo:

gem install bundler

Ele utiliza como referência para o seu trabalho o arquivo Gemfile, que é onde você adiciona todas as dependências do seu projeto. Algo como o exemplo abaixo.

source 'https://rubygems.org'

ruby '2.1.2'

# Rack

gem 'rack', '~> 1.5.2'

gem 'grape', '~> 0.8.0'

Na linha “source” é onde você diz para o bundler ir buscar os arquivos, existem algumas alternativas ao rubygems como o rubyforge, github ou bitbucket. É onde a sua gem está hospedada.

A segunda linha indica qual versão do Ruby necessária para rodar o seu projeto. Você pode user o rbenv ou o rvm para gerenciar as versões instaladas na sua máquina, outro dia falo mais sobre eles em algum post.

A linha com a hash # é uma linha comentário, o próprio dispensa comentários ;)

As duas últimas linhas dizem ao bundler quais dependências o seu projeto precisa,

gem <nome>, '<versao>'

O nome não tem segredo, já a versão é cheia de macetes:

‘1.5.2’ caso você coloque somente a versão, ele vai instalar especificamente a mencionada;

‘~> 1.5.2′ caso você coloque “~>”, significa que o bundler pode instalar versões maiores ou igual a 1.5.2 porém menor que 1.6

‘~> 1.5′ significa que o bundler pode instalar versões maiores ou igual a 1.5 porém menor que 2.0.

‘>= 1.5.2′ caso você coloque “>=” entram as versões maiores ou iguais

Posso utilizar uma gem armazenada diretamente na minha maquina adicionando o seguinte:

gem '<nome>', '<versao>', path: '<path-da-gem>'

Posso também falar que a gem está em um repositório git:

gem '<nome>', '<versao>', git: '<url-do-repositorio-git>'

Posso também falar que está em um repositório do github:

gem '<nome>', '<versao>', github: '<usuario-do-github>/<nome-do-projeto>'

Com o andamento do projeto o seu arquivo vai crescer, e você vai acabar percebendo que nem todas as gems são necessárias para rodar o seu projeto em produção por exemplo. Algumas são para te ajudar no debug em ambiente de desenvolvimento, você pode agrupar as gems para otimizar o seu projeto:

group :development do
gem 'pry'
gem 'byebug'
end

ou adicionar a cada gem:

gem '<nome>', '<versao>', group: [:development, :test]

Quando simultâneamente ao desenvolvimento do seu projeto, você precisa modificar uma gem que você também mantém, você pode utilizar a alternativa de apontar para um determinado path da sua maquina, porém quando for fazer o deploy, terá problemas pois o ambiente de produção é diferente do seu, para contornar isso, costumo fazer a seguinte combinação.

Adiciono no Gemfile a branch que estou trabalhando na minha máquina:

gem 'minha_gem', git: 'git@bitbucket.org:fabiotomio/minha_gem.git', branch: 'feature/nova_funcionalidade'

E no terminal, configuro o bundle para utilizar os arquivo em um path específico na minha maquina.

bundle config local.minha_gem ~/Projects/gems/minha_gem

Para remover:

bundle config --delete local.minha_gem

Uma vez o seu Gemfile criado, e suas gems configuradas dentro dele é só executar o comando:

bundle install

O Bundler entrará em ação e irá baixar todas as gems em suas versões dos repositórios definidos para o seu projeto rodar! =DDD

Quando ele terminar, aparecerá um arquivo chamado Gemfile.lock que nele estão congeladas as versões de todas as gems instaladas.

Quando ele existir o Bundler levará ele (Gemfile.lock) em consideração e não o Gemfile, a explicação disso é simples, como as gems são mantidas por muitas pessoas e caso você não especifique uma versão da mesma, o que é muito comum de alguns desenvolvedores fazerem, existe a possibilidade de você não conseguir rodar o seu projeto quando você for fazer o deploy por exemplo, depois de alguns dias de desenvolvimento, pelo simples motivo da gem ser atualizada pela comunidade e justamente as funcionalidades que você consumiu terem mudado, o seu projeto pode quebrar! Por isso é interessante entender como é feito o versionamento e qual a diferença entre os “numerozinhos” que definem cada versão e adicionar essa informação no Gemfile!

Tem muita coisa ainda pra falar sobre o Bundler, mas acho que pra quem está com um pouco de dificuldades e quer uma dose homeopática sobre o bundler, consegui cumprir com esse texto. Essas informações já vão desmistificar um pouco o Gemfile, e ajudar você com os diferentes ambientes que precisamos lidar no dia a dia do desenvolvimento.

Não tenho a ambição de cobrir todo assunto, para os curiosos, seguem alguns links que podem ajudar:

http://bundler.io/#getting-started
http://www.caelum.com.br/apostila-ruby-on-rails/a-linguagem-ruby/#2-4-bundler
http://bundler.io/v1.3/man/bundle-config.1.html
http://stackoverflow.com/questions/4487948/how-can-i-specify-a-local-gem-in-my-gemfile
http://ryanbigg.com/2013/08/bundler-local-paths/
http://oldblog.judofyr.net/posts/dont-forget-about-rubyforge.html

Grande abraço e até a próxima.

Dashboard para Arduino – dashduino.com

Estou encantado com as possibilidades de projetos que envolvem open-source hardwares, mais especificamente com o Arduino, mas em contrapartida, acho muito precária a interação homem-maquina. Na minha visão, a facilidade de conexão de shields é inversamente proporcional a interação humana no processo.

Desse problema surge um projeto pessoal, o dashduino.com, a idéia é prover uma plataforma de interação com o seu Arduino que possuir acesso à Internet, provendo os recursos de:

  • logger;
  • gerenciamento de eventos;
  • interligação de projetos em rede utilizando a Internet;
  • agendamento de eventos;
  • compartilhamentos nas redes sociais;
  • gráficos;
  • entre outras idéias.

Estou desenvolvendo uma library em C, para facilitar a implementação e o consumo desses recursos do lado do Arduino, que vou disponibilizar no github, uma plataforma web que será o dashboard, e em um futuro talvez não distante, um app para você instalar no seu celular e ter acesso a tudo! \o/

Vou iniciar com a parte do logger e no decorrer do ano irei liberando as demais funcionalidades.

A idéia é deixar a plataforma gratuita até o final do ano e logo após isso estimar os custos envolvidos e definir os planos.

Logo logo posto mais informações, comecei os trabalhos esse final de semana, em mais alguns dias tenho uma versão beta, assim que estiver rodando compartilho aqui o link.

 

Arduino + Módulo Ethernet ENC28J60

Recentemente comprei um módulo Ethernet ENC28J60, para conectar ao meu Arduino Uno, pensei que seria simples como foi ligar o drive para controle de motor de passo, mas não foi bem assim!

Para simplificar, vou me referir ao “Shield Ethernet” oficial do Arduino somente pelo nome shield, e o “Módulo Ethernet ENC28J60″ somente de módulo.

Como o módulo não era o “original” precisei adicionar novas bibliotecas no Arduino Software, alguns blogs falam pra deletar as libraries quem acompanham a ferramenta de desenvolvimento, como não gostei muito dessa idéia, continuei a estudar se teria um jeito mais simples e sem ter que deletar nada. Cheguei no passo a passo abaixo.

  1. Baixe a biblioteca desse link: Ethercard
  2. Adicione ao seu Arduino Software clicando em: Sketch -> Import Library -> Add Library e selecionando o arquivo Ethercard.zip baixado na passo anterior.
  3. Compile e faça o upload do programa abaixo para o seu Arduino:
    #include <EtherCard.h>
    
    // Caso queira definir um ip estático mude de 0 para 1
    #define STATIC 0 
    
    #if STATIC
    // Endereço IP estático a ser definido a interface Ethernet
    static byte myip[] = { 192,168,1,200 };
    // Endereço IP do Gateway da sua rede
    static byte gwip[] = { 192,168,1,1 };
    #endif
    
    // MAC Address da interface ethernet - deve ser único na sua rede local
    static byte mymac[] = { 0x74,0x69,0x69,0x2D,0x30,0x31 };
    
    byte Ethernet::buffer[500];
    
    const char page[] PROGMEM =
       "HTTP/1.0 200 OK\r\n"
       "Content-Type: text/html\r\n"
       "Refresh: 5\r\n"
       "\r\n"
       "<html>"
       "   <head>"
       "      <title>Arduino Web Server</title>"
       "   </head>"
       "   <body>"
       "      <h3>Página resposta do seu Arduino.</h3>"
       "      <p><em>fabiotomio.com.br.<br />=D</em></p>"
       "   </body>"
       "</html>"
    ;
    
    void setup(){
       Serial.begin(57600);
       Serial.println("\n[webserver]");
    
       if (ether.begin(sizeof Ethernet::buffer, mymac) == 0)
          Serial.println( "Failed to access Ethernet controller");
       #if STATIC
          ether.staticSetup(myip, gwip);
       #else
          if (!ether.dhcpSetup())
             Serial.println("DHCP failed");
       #endif
    
       ether.printIp("IP: ", ether.myip);
       ether.printIp("GW: ", ether.gwip);
       ether.printIp("DNS: ", ether.dnsip);
    }
    
    void loop(){
       if (ether.packetLoop(ether.packetReceive())) {
          memcpy_P(ether.tcpOffset(), page, sizeof page);
          ether.httpServerReply(sizeof page - 1);
       }
    }
    
  4. Após fazer o upload do programa para o Arduino, abra o “Serial Monitor”, deverá aparecer algo como na imagem abaixo:
  5. Agora é só acessar o endereço IP utilizando o seu navegador preferido:

Note que o texto que aparece é o HTML correspondente às linhas 19 a 31 do programa que compilamos e fizemos o upload pro Arduino!

Mas você deve estar se perguntando, quais pinos ligar onde, não é!?

A ligação do módulo é quase igual ao shield oficial descrito na imagem abaixo:

Pinos Shield Original - Arduino + Ethernet Module - Programa backSoon

encontrado nesse link: http://arduino.cc/en/reference/ethernet

A diferença fica no pino correspondente ao “SS for Ethernet controller“, que no Módulo Ethernet ENC28J60 é chamado de Pino CS, que é conectado no pino 8 ao invés do pino 10. Como o nosso módulo não contempla o leitor de cartões como o shield, o “SS for SD card” não tem nenhum pino correspondente no módulo, por motivos óbvios. Veja abaixo a tabela que correlacionando os pinos:

Módulo Ethernet Arduino UNO
Pino CS Pino 8
Pino SI Pino 11
Pino SO Pino 12
Pino SCK Pino 13
Pino VCC Pino 3.3V
Pino GND Pino GND

Segue uma imagem pra ilustrar a conexão do módulo com o Arduino que peguei na net.

Módulo conectado - Arduino + Ethernet Module - Programa backSoon

Claro que o meu não ficou tão bonito assim! ;)

Creio que é isso… Tenho umas idéias para o Arduino mais esse módulo Ethernet, vou postando aqui no blog os avanços!

Grande abraço a todos e qualquer dúvida é só entrar em contato!

Dica: Com a library, vieram alguns exemplos! lol O código que coloquei aqui é baseado em um dos exemplos! Tem coisas bacanas que você pode usar como referência para desenvolver o seu projeto, para acessar, entre no menu em: File -> Examples -> Ethercard e escolha um exemplo.

Referências:

http://www.geeetech.com/wiki/index.php/Arduino_ENC28J60_Ethernet_Module

http://nathanhein.com/2013/02/getting-arduino-online-with-an-enc28j60/

http://hofmannsven.com/2013/laboratory/arduino-ethernet-module/

http://stackoverflow.com/questions/8736791/arduino-dhcp-not-working

https://www.sparkfun.com/tutorials/409

http://helpdev.com.br/2013/07/07/arduino-criando-servico-web-com-ethernet-shield/

Repositório da biblioteca no github: https://github.com/jcw/ethercard

Gerenciador de projetos da biblioteca: http://jeelabs.net/projects/ethercard

Atualização 01: Mudei o conteúdo da pagina entregue pelo Arduino para um conteúdo mais amigável, atualizo as imagens na sequência. 07-05-2014
Atualização 02: Atualizei as imagens. 08-05-2014