Dicas

Programando o ESP8266 com Javascript (node.js)

nodemcu_plusnodejs

Apresentar o nodeMCU e o ESP8266 acredito não ser necessário, afinal você já sabe que ele o NodeMCU (ESP8266) é o módulo que desbanca o Arduino e facilitará a Internet das Coisas… (by Irving.com.br) :). Para ficar ainda mais interessante, seria legal poder controlar esse carinha usando javascript, não seria ? Pensando nisso procurei uma forma de possibilitar essa união de forças, trazendo pro node o poder do JS.

Para facilitar e mostrar o poder dessa união, vamos juntos executar o exemplo de “Blink”, o clássico “hello world” dos microcontroladores, porém vamos escreve-lo em Javascript.

Meu ambiente é um ubuntu 14.04, porém sem muito esforço esse exemplo deverá funcionar em Macs e Windows.

O segredo dessa junção é o protocolo Firmata, que possibilita uma comunicação entre o computador e microcontroladores, com o firmware instalado no microcontrolador, esse carinha pode usar praticamente todas as funções do microcontrolador “de fora”, atraves da serial, porém serial nao seria legal com o nosso ESP8266, afinal do que adiantaria um chipizinho com Wifi se ele precisasse ficar conectado ao computador ? Ai entra uma bliblioteca no “arduino” e uma(s) no node.js, vamos aos passos:

  • Baixar a ultima versão da IDE do Arduino
  • Ter um ESP (não diga!)
  • Ter a ultima versão da biblioteca Firmata
  • Ter a ultima versão da biblioteca  johnny-five
  • Instalar o Etherport-client (o mágico).

Os dois primeiros passos, basta seguir as instruções na página do “Arduino core for ESP8266 WiFi chip” [link]

Agora é importante ter a ultima versão da biblioteca do firmata no seu arduino, pois somente na ultima versão tem a entrada para as placas ESPs, pra fazer isso, vá até o diretório onde ficam as bibliotecas do Arduino, e faça um clone do projeto, talvez você já tenha uma pasta do Firmata, nesse caso apague, ou se o medo bater na sua porta, faça um backup dela.

1
2
3
$ cd ~/Arduino/libraries/
$ rm -rf Firmata
$ git clone https://github.com/firmata/arduino.git Firmata

Nesse momento já temos “quase” pronto o lado do ESP, pra finalizar vamos subir o código do StandardFirmataWiFi para o ESP (File->Examples->Firmata->StandardFirmataWiFi), lembrando que é necessário configurar a sua rede Wifi (usuário e senha) no arquivo wifiConfig.h:

char ssid[] = "<sua rede wifi>";

char wpa_passphrase[] = "sua_frase_wpa";

Agora sim, só clicar em upload e esperar o node ficar com as duas luzes acesas:

IMG_20160601_012524

Vamos agora configurar o “host”, se você ainda não tem o node.js instalado, faça isso já! e então você poderá baixar os pacotes npm abaixo:

1
2
3
$ npm install johnny-five
$ npm install johnny-five
$ npm install firmata

Agora é hora de colocar código de um lado e ver se do outro lado sai luz piscando 😉

 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
27
28
29
30
31
32
33
34
35
36
37
38
39
/*
 * Update line 18 below to the ESP8266 board address
 *
 * Enable Serial debugging by uncommenting //#defin SERIAL_DEBUG in StandardFirmataWiFi
 * (save a copy of StandardFirmataWiFi first)
 *
 * On startup (you may have to reset the ESP board because it starts up really fast
 * view the Serial output to see the assigned IP address (if using DHCP)
 * Or if you want to give the board a static IP (not use DHCP) then uncomment the
 * following lines in wifiConfig.h and update to your chosen IP address:
 * #define STATIC_IP_ADDRESS  10,0,0,17
 * #define SUBNET_MASK        255,255,255,0 // REQUIRED for ESP8266_WIFI, ignored for others
 * #define GATEWAY_IP_ADDRESS 0,0,0,0       // REQUIRED for ESP8266_WIFI, ignored for others
 */
var Firmata = require("firmata").Board;
var EtherPortClient = require("etherport-client").EtherPortClient;
var board = new Firmata(new EtherPortClient({
  host: "192.168.0.105",
  port: 3030
}));

board.on("ready", function() {
  console.log("READY!");
  console.log(
    board.firmware.name + "-" +
    board.firmware.version.major + "." +
    board.firmware.version.minor
  );

  var state = 1;

  this.pinMode(13, this.MODES.OUTPUT);
  this.digitalWrite(13, 1);
  setInterval(function () {
    console.log(state);
    this.digitalWrite(13,(state ^= 1));
  }.bind(this), 1000);

 });

 

Salvou, ligou os fios* e rodou!

led-13

1
 $ node nome_do_arquivo.js/

\o/

Como eu disse no começo, aqui está a ponta do iceberg, agora da pra deixar a imaginação correr solta e criar diversos projetos legais, mãos a obra!

Para concluir

Ainda que esse modelo não estamos rodando JS dentro do microcontrolador e ficamos na dependência de um computador externo enviando dados, acredito que não devemos desprezar nosso Firmata Wifi, afinal temos bastante gente que se familiariza com javascript, e diversas soluções aonde já haverá um computador orquestrando os microcontroladores… E outra, é JS, fácil de integrar com qualquer coisa ;D

Fonte: Boa parte dos achados, encontrei aqui

Padrão
Dicas

Arduino 101 + Ubuntu 14.04

Placa e Caixa do Arduino 101Cheguou aqui no garagem da CI&T o “novo arduino uno”, com processador Intel Curie, que como principais caracteristicas, vem com BLE, que é o Bluetooth Low Energy, com um acelerometro de 6 eixos, entre outras coisas legais como o controlador de Timer.

Pensando em colocar a plaquinha pra fritar, resolvi ligar aqui no meu linux, Ubuntu 14.04 e ai começou as primeiras diferenças entre os outros arduinos e esse. Primeiro precisei baixar as Boards da Intel, lá no menu Tools -> Board -> Board Manager, e escolhendo Intel Curie Boards. Feito isso tentei subir o exemplo “Blink”, aquele que faz o led 13 piscar e nada, só mensagens de erro na IDE:

dfu-util: Cannot open DFU device 8087:0aba

Alem, dele ficar me pedindo pra apertar o botão de Master Reset… Como não foi uma solução trivial, ainda que rápida de resolver, aqui vai uma receitinha de bolo pra ele funcionar no Ubuntu:

  1. Instalar o dfu-util no seu linux
    1. sudo apt-get install dfu-util
  2. Executar o script pra criar o dfu-udev, para isso bastou executar:
    1. sudo /home/{seu_usuario}/.arduino15/packages/Intel/tools/arduino101load/1.6.4+1.18/scripts/create_dfu_udev_rule
  3. Depois disso tentar subir novamente o código do Blink e sucesso!

E para ficar mais legal, na parte de exemplos agora existem alguns diretórios Curie* com exemplos de como usar as novidades da placa.

Não sei se no windows é pra ter problema, mas se tiver, só desinstalar e instalar o Ubuntu e correr pro abraço ;)… (Brincadeirinha, qualquer coisa se alguem tiver dificuldade ou souber como resolver, deixa ai nos comentários).

Veja mais informações do Arduino 101 aqui na página oficial

Padrão
bomba_v2.1
Projetos

B.O.M.B.A. – O Vídeo

Faz um tempo que terminamos o projeto (final de janeiro), porém não tinha atualizado o blog ainda. Aqui está o resultado final, arduino “stand-alone” ligado na plaquinha, com os botões já OK, podendo ser montado em uma maleta, ou qualquer lugar que se queira, de maneira fácil e prática.

Ficou 100%, em breve uma versão 2 com alguns pequenos ajustes.

[Atualização] Uma foto do “produto final”

bomba_v2.1

Padrão
Projetos

B.O.M.B.A.

fig. 0

Máquina de Estados (fig. 0)

A história começou assim:

– Meu, e se nos fizéssemos uma bomba estilo CS para jogar AirSoft ? (lucas)
– Poxa, serial legal, daria uma dinâmica diferente, vamos fazer? (eu)

Apesar de nunca ter jogado AirSoft, curti a ideia  daria para usar este dispositivo não só nos jogos de AirSoft, mas também nos jogos de Paintball, já que são basicamente a mesma coisa, e com isso mais um modo de jogo seria viável, não só as variações de Capture the Flag.

Dito isso, vamos aos desafios do projeto.

Combinamos que o dispositivo deveria ser capaz de:

  • Configurar o tempo de disparo
  • Apitar quando o tempo acabar
  • Ter a opção de “cortar o fio”

Simples? Nem tanto.

Definimos que o dispositivo teria três botões, sendo um deles responsável por acessar e sair do menu de configurações, os outros 2 são o botão de + (mais) e o de (menos), que quando no estado de configuração aumenta e diminui o tempo de disparo, já quando a bomba estiver armada, um será o botão que irá desativar a bomba, outro o “fio errado”, que são escolhidos randomicamente.
Como feedback teríamos displays de 7 segmentos (fig. 2), mostrando tempo restante… e um buzzer (fig. 1), pra gritar, quando o fio errado fosse cortado, ou o tempo acabasse.

fig. 1

fig. 1

Display de 7 Segmentos

Display de 7 Segmentos

Tendo isso em base, fiz vários testes, primeiro aprendendo como o display funciona, na raça, aqueles números estranhos, precisei fazer ele funcionar com 2 displays juntos, fio pra todo o lado, olha que “beleza”:

Vamos caminhar para a versão “final”, lembrando que meus skills são limitados na questão elétrica/eletrônica, vou relatar algumas coisas que aprendi e como montamos o projeto.

Os displays de 7 segmentos são de 2 possiveis tipos, Anodo comum e Catodo comum [mais informações].
Para que eles funcionem você deverá pegar o esquemático, observar as indicações dos pinos A B C D E F G, os comuns e então debruçar sobre o protobord, programar o arduino e verificar se está como o esperado.
Feito isso pra um, você pode tentar fazer pra 2 simultâneos, dobrando os fios e ficando de cabelo em pé 🙂
Eu fiz isso, apesar do trabalho, ficou bacana, até gerei uma “quase” biblioteca pra facilitar a programação. Já quando estava tudo certo, recebi uns pacotinhos chineses com novos displays, agora com 4 dígitos, o que daria ao projeto uma cara bem melhor, resolvi estudar mais um pouco e trabalhar direto com esse componente, ao ver o esquemático, percebi que existia uma forma de facilitar a vida no exemplo que comentei acima, usando 2 displays de 1 digito cada, por causa disso podemos ligar esse display com o dobro de dígitos “sem” fios adicionais, vale dar uma estudada no assunto.

Passeando pelo forum do Arduino encontrei uma biblioteca muito joia;), que facilitou um tantão na hora de fazer esse novo display mostrar valores, seu nome é Seven Segment Display Library. Para usa-la foi bem tranquilo, bastou inicializar, dar um printout e mostrar o numero, veja:

[sourcecode language=’cpp’]
sevseg.Begin(1,2,3,4,5,6,7,8,9,10,11,12,13); // Configuração

// Imprimindo o número
sevseg.PrintOutput();
sevseg.NewNum(1234,2);
[/sourcecode]

Já com o display funcionando, agora era codificar a “maquina de estados”(fig. 0). e colocar a coisa pra andar.

Na cronologia da construção, essa etapa ocorreu de forma incremental ;), pois fui evoluindo a ideia até o que ela é hoje.
Como nossa bomba é uma bomba relógio, era necessário que alguém ou alguma coisa que contasse os segundos, pra que o resto fosse montado em torno dessa contagem. Nesse momento contei com a ajuda da biblioteca SimpleTimer, nela você define eventos, eles podem executar uma vez, algumas vezes, ou sempre, de Tempos em Tempos,.. tudo o que precisava (antes eu fazia na mão as continhas ;)).
[sourcecode language=’cpp’]
SimpleTimer timer; // Configuração

// Repete sempre!
void repeatMe() {
// do something
}
timerId1 = timer.setInterval(1000, repeatMe);

// Chama a função depois de X tempo
void callMeLater() {
// do something
}
timerId2 = timer.setTimeout(1000, callMeLater);

// repete 5 vezes
void repeatMeFiveTimes() {
// do something
}
timerId3 = timer.setTimer(1000, repeatMeFiveTimes, 5);
[/sourcecode]

No sistema da bomba utilizei os timers para: – contar segundos, – contar segundos restantes, e alguns outros timers auxiliares.

Além de toda essa confusão, precisava ligar o Buzzer, responsável pelo feedback sonoro, mostrando quando o usuário navega entre as opções, e quando a boma estoura. No decorrer da construção resolvi colocar um feedback visual, de forma que fosse possível detectar em qual estado a maquina se encontra: – Em aguardo, – Em configuração, – Armada, – Disparada, fiz isso usando um LED, bem simples, como mostro no vídeo de demonstração do projeto.

Para não virar um projeto “em andamento” pra sempre, resolvi soltar a versão 1, ainda sem um detalhezinho, o barulho de feedback da bomba quando armada, ainda não funciona.

Padrão
Projetos

Arduino HackDay ?

Olhando pela internet, descobri algo bem interessante…

Em diversos lugares, por todo mundo, estão se organizando em eventos, os chamados Hackdays, geralmente acontecem durante um dia todo, de manhã até de tarde/noite…. e por isso – Hackday 😉

Pensando em como disseminar a idéia do Arduino aqui na região, resolvi “agitar” o pessoal de Sta. Barbara D’Oeste (meus alunos) a fazer uma noide no estilo do Hackday. Ainda que o tempo seja curto, a idéia é plantar a semente.

Para o primeiro Hackday, atividades simples na parte eletrônica, mostrando basicamente como o Arduino funciona, alguns acionamentos (leds/servos), coisas simples mais que todos os participantes poderão fazer.

Infelizmente há uma falta de placas pra todos, porém irei disponibilizar duas delas, de forma que 2 grupos possam atuar simultanemante.

Pro evento ficar mais legal, se o tempo permitir, conversaremos sobre programação, e tentaremos montar uma lógica para aplicar no projeto do “Carrinho de Controle Remoto” (que agora tem um super controle e virou um tanque [em breve posto aqui]).

A data do evento ficou para dia 07/out/2k11 na FAC de Sta Barbara D’Oeste, evento somente para alunos.

Conteúdo

 

  • O arduino
  • Possibilidades
  • Vídeos
  • Mão na massa

Piscando os Leds (Blink) [link]
Botão [link]
Semaforo simples (sem acionamentos extras) [link]
Semaforo com acionadores [link]

Se tudo ocorrer bem, posto aqui o relatório do evento!

Padrão
Dicas

Arduino IDE 1.0-beta1

Conferi a alguns dias que o pessoal do core team do arduino soltou a vesão beta da IDE, como as coisas que eu faço são testes, resolvi ver as novidades, de cara, uma interface mais clean, vejam:

Além da mudança do visual, agora os arquivos passam a ter a extenção .INO, o que ao meu ver, é uma mudança legal, pra mim, .INO faz muito mais sentido do que .PDE 😉 …

O pessoal do Laboratório de garagem foi mais afundo e comentou que as mudanças aconteceram principalmente nas bibliotecas de rede e em algumas outras, porém na maioria das vezes o programa ficará com o mesmo tamanho.

Porém faço aqui um adendo, nos meus projetos, como tenho aquelas bibliotecas de terceiro, como a pro sensor ultrasonico HC-SR04 que utilizo no meu carrinho, ao compilar a primeira vez ele me deu falha, não estava encontrando a WProgram.h, observando como as bibliotecas Ethernet, Servo e algumas outras do próprio projeto do Arduino, constatei que a Wprogram não está mais sendo usada, porém (até aonde testei…) ela foi substituida por 2 outras:

#include <Arduino.h>
#include <inttypes.h>

Bastou então para o programa passar a compilar, comentar a WProgram.h e incluir essas dudas.

Como não achei nenhuma informação na internet (forum do arduino) resolvi escrever aqui pra ajudar os que também tiverem esse problema.

Padrão
DSC04013_feito
Projetos

Carrinho “Power”

Dia 24 de março apresentei a vocês o que seria o carrinho, ainda que primitivo já estava ao menos com cara de carrinho. Desde então, muitas idas e vindas aconteceram com o “danado”, vou relatar algumas delas aqui:

A primeira idéia foi criar logo o carrinho, sem muita idéia de como ele iria detectar objetos, ou fazer algum tipo de interação, nesse momento idéias fervilhavam na cabeça, em mãos tinha um controle remoto (que veio no meu starter kit)  e alguns botões vindos dos CDRoms desmontados.
O escolhido nesse momento foi, “controle remoto”, mais simples e aparentemente menos problemático, montei o  circuito e mãos a massa.

Codifiquei todas as ações que desejava para o carrinho (código), tudo parecia simples, porém… como não poderia ser diferente… alguns acertos foram necessários na configuração dos motores, acertos feitos, robo feliz e contente, andando porém longe do objetivo.. que era fazer algo autônomo (robô).

Mais alguns finais de semana, resolvo então implementar o para choque com os botões de fim de curso, com um pouco de dificuldade na parte mecânica da coisa, porém ainda assim, no final de tudo, funcional. Imagine que o carrinho tinha na frente um botão de fim de curso, quando esse botão era acionado (batida) então o carrinho voltava, mas era extremamente difícil do carrinho bater de forma a pressionar o botão (mais uma vez, falha no projeto com relação as partes mecanicas ;)).

Nesse meio tempo, no fervilhão de idéias, existia também o leitor de RFID, que por essa limitação do botão não ser pressionado com “qualquer” batida, resolvi implementar uma chave de liga/desliga, aonde ao bater, o carrinho daria marcha-ré e viraria, depois ficaria esperando um “Ligar” proveniente do RFID (código). Como na primeira parte do vídeo(logo abaixo)

Já em data mais próxima aos dias atuais (cerca de 4 semanas) chegou o sensor ultrasônico HC-SR04, ai a coisa começou a ficar mais “profissa”. Sensorzinho porreta, e mais barato do que o Ping))) da Parallax (deve existir algum motívo para isso), capaz de medir até 4 metros de distãncia. (Diz o manual que é 4 e meio :P). Essa caracteristica me permitiria não precisar mais do para-choque, pois antes mesmo de bater, já saberia da existência de um objeto na frente do carrinho. Porém nem tudo são flores… mas deixamos as flores pra depois.

Nesse interim chegou também o resto dos meus servo motores, dessa forma os projetos “poderiam” ganhar várias possibilidades, porém tudo que o carrinho ganhou foi a possibilidade de olhar pra “todos os lados”, melhor dizendo, com o servo motor e o sensor ultrasonico, poderia medir a distancia ao redor do carrinho, bem pratico. Porém pra que isso funciona-se, foi necessário refazer o código e então, como vocês podem ver no vídeo abaixo depois de alguns ajustes relacionados a distância de detecção e então a coisa começou a andar (e sem bater … o que é mais importante)

… As flores …

Os para choques ainda são necessários, pois alguns objetos não são detectados a tempo, as vezes são muito fino ou algo aonde o sensor ultrasonico não da conta, e então o robô estava batendo. Aumentei a distancia de detecção, o que melhorou bastante porém ainda assim é necessário implementar um para choque.

Dependendo do piso, o pneu do carrinho escorrega, prejudicando assim o “bom andar” dele. breve substituirei a rodinha tradicional pela longarina (roda de tanque) para ver se esse problema é amenizado.

Algumas fotos (incluindo o fritzing):

Padrão