Intel Galileo Gen2 – Paraíso dos Bits

Utilizando Node.JS na Intel Galileo Gen2

Olá a todos,

nesse post demonstraremos como podemo desenvolver aplicações WEB, utilizando Node .JS com a nossa placa Intel Galileo Gen2. Dessa forma poderemos transformar nossa placa em um servidor WEB que poderá ser acessado na nossa rede local ou mesmo na internet, se atribuirmos um IP de internet à nossa placa.

Antes de escrevermos nossos códigos em C++ no Eclipse precisamos colocar nossa placa na rede. As instruções para essa tarefa estão nos posts Conectando a Intel Galileo Gen2 na rede local e Conectando a Intel Galileo Gen2 na rede WiFi.

Com a Intel Galileo na nossa rede o próximo passo é instalar serviço de impressão Bonjour da Apple (apenas para computadores com Windows). Esse serviço é necessário para que o XDK IoT Edition reconheça sua placa na rede. Para instalar esse serviço baixe o instalador no site da Apple.

O passo seguinte é instalar o Intel XDK IoT Edition que é o IDE para escrevermos nossos programas em Noje.JS. Faça o download do instalador no link https://software.intel.com/en-us/articles/install-the-intel-xdk-iot-edition. O instalador deve ser executado com permissão de administrador (clique com o botão direito do mouse sobre o arquivo e selecione a opção Executar como Administrador). Será aberta a tela do instalador do XDK IoT Edition. Siga as instruções do instalador.

Nesse momento teremos o ambiente pronto, precisamos então realizar um pequeno teste para validar a montagem do ambiente.

Primeiro monte o circuito conforme descrito no esquema abaixo. Esse circuito é semelhantes ao circuito montado para testarmos o envio de sinais digitais em um post sobre Arduino.

Após a instalação execute o IDE. Na primeira execução deverá aparecer uma mensagem solicitando a liberação no firewall do Windows para o IDE acessar a internet. Clique no botão Allow Access.

Em seguida será aberta a tela inicial do IDE, solicitando o login ou que seja criada uma conta no ambiente da Intel. Após criar sua credencial ou realizar o login deverá aparecer a tela principal do XDK IoT Edition. Selecione a opção Start a New Project para iniciar um novo projeto.

Será aberta a tela para selecionarmos um template de projeto. Selecione o template Simple Web Server e clique no botão Continue. Na tela seguinte preencha o campo Project Name com o nome do projeto.

Depois de criado o projeto abra o arquivo package.json para incluirmos alguns módulos no projeto. No trecho dependencies inclua os módulos express e body-parser como na imagem abaixo. Esses módulos facilitam o desenvolvimento de aplicações web em Noje.JS como veremos a seguir.

O próximo passo é editarmos o arquivo main.js, que possuí o código da nossa aplicação. Ao abrir o arquivo remova todo o seu conteúdo. Em seguida inicie os módulos express, body-parser, util e mraa conforme a imagem abaixo:

O próximo passo é declaramos e iniciarmos as variáveis que controlarão os valores dos pinos que estão ligados aos leds conforme o trecho abaixo:

Em seguida declare uma função que controlará os valores dos pinos e escreverá o código HTML para ser exibido no navegador:

Agora escreva as funções para o webserver processar as requisições do tipo GET e POST e retornar a página HTML. A requisição do tipo GET coloca todos os pinos em estado baixo (LOW) e retorna a página com as caixas de seleção como não selecionadas. As requisições do tipo POST alteram os valores do pino e informam o valor selecionando a caixa quando o estado for HIGH ou não a caixa de seleção quando o valor for LOW:

Para encerar o código inicie o webserver com o método listen. Esse método recebe como parâmetro a porta em que o webserver está recebendo as requisições:

Com o programa pronto devemos configurar a conexão com a nossa placa. Na parte inferior do IDE selecione a opção [+] Add Manual Connection no campo IoT Device. Será aberta a janela de configuração de conexão. Informe o endereço IP da placa, mantenha os demais valores e clique no botão Connect.

Com a conexão configurada clique no botão Install/Build (ícone com um martelo) para baixar e instalar os módulos express e body-parser. Em seguida clique no botão Upload (ícone com uma caixa e uma seta, localizado a esquerda do botão Install/Build) para transferir o programa para a placa. O último passo é clicar no botão Run (ícone com um fluxograma e uma seta verde) para iniciar o programa.

Com o programa iniciado abra um navegador de internet e digite o endereço HTTP://<endereço IP>:<porta>, onde o endereço IP é o endereço IP da placa e a porta é a placa do WebServer que foi passada como parâmetro no método listen. Deverá ser exibida no navegador a página da nossa aplicação:

Selecione alguma das caixas de seleção e clique no botão Submit Query. Os valores das caixas serão enviados para a Intel Galileo Gen2 que alterará os valores do pino e mostrará o novo estado dos leds na tela.

Também é possível depurarmos os programas em Node.JS. Para iniciar um programa em modo depuração clique no botão Debug, que possuí o desenho da barata com o triangulo que fica no lado direito do botão Run. Será aberta a tela de debug.

Podemos adicionar breakpoints clicando no número da linha do código. Para iniciar a aplicação clique no botão com o símbolo Play azul localizado na parte superior direita da tela. Aguarde a aplicação iniciar e acesse o mesmo endereço utilizado anteriormente.

Nesse ponto temos uma aplicação web que poderá ser utilizada em nossa rede local ou através da internet caso seja configurado um endereço IP público para a nossa placa.

Onde encontrar:

Obrigado a todos e até o próximo post!

Escrevendo código em C++ para Intel Galileo Gen2

Olá a todos,

nesse post mostraremos como configurar o nosso ambiente, composto do nosso computador e da placa conectados via rede, para desenvolvermos softwares em C++ para nossos projetos. Para esse desenvolvimento utilizaremos uma versão especial do Eclipse provido pela Intel.

Você também precisa verificar se possui o Java 8 instalado em seu computador. Os instaladores do Java podem ser encontrados aqui.

Após colocar a placa na rede precisamos instalar o eclipse. Para isso baixe o eclipse do site da Intel a partir do link https://software.intel.com/en-us/installing-the-eclipse-ide. Você precisará utilizar o 7ZIP para descompactar o arquivo.

Tenha certeza que o caminho completo do Eclipse, que são os nomes de todas as pastas onde o arquivo foi descompactado, não possua o caractere espaço em branco, pois isso poderá fará aparecer uma mensagem de erro ao iniciar.

Após extrair o conteúdo do arquivo entre na pasta iotdk-ide-win e localize o arquivo devkit-launcher.bat. Dê um duplo clique nesse arquivo para iniciar o com todas as configurações necessárias para desenvolvermos nossos programas para a Intel Galileo Gen2, inclusive com o suporte às bibliotecas libmraa e upm.

Na primeira execução pode aparecer a mensagem abaixo solicitando a atualização das bibliotecas MRAA e UPM. Clique no botão Yes e aguarde o término da atualização.

Na sequência será aberta a janela para selecionar a pasta da workspace, que é o local onde os projetos serão armazenados. Selecionado o local da worskspace do Eclipse será aberta sua janela inicial:

Para iniciar o projeto monte o mesmo circuito descrito no post sobre como controlar motor DC com o Arduino.

Passaremos agora para o desenvolvimento do código. Inicie o projeto selecionando o menu File -> New -> Intel(R) IoT C/C++ Project. Será aberta uma janela que contém diversos modelos de projetos. Os modelos da pasta Grove Starter Kit possuem códigos de exemplo para trabalharmos com os pinos da Intel Galileo Gen2 e podem nos ajudar a migrar um projeto em sketch para código C++. Selecione o modelo PWM, pulse with modulation e informe um nome para o projeto no campo Project Name, que está na parte superior da janela. Em seguida clique no botão Next.

Será aberta a janela para configurar a conexão com a placa Intel Galileo Gen2. Clique no botão Search Target para abrir a janela onde você deverá informar o nome e endereço IP da placa. Nessa janela informe um nome para a conexão no campo Enter connection name e o endereço IP da placa no campo Enter Target name or IP address. Em seguida clique em OK, retornando para a janela anterior e clique no botão Finish. Aguarde o modelo do projeto ficar pronto.

Vamos examinar o código da função main. Primeiro é identificado se o código é executado em uma placa Intel (Galileo Gen1, Galileo Gen2 ou Edison) com o uso da função mraa_get_platform_type. Essa função retorna qual o modelo de placa em que o código está em execução.

Em seguida é criado um ponteiro para um objeto do tipo Pwm e esse objeto é criado. Note que no construtor do objeto é informado qual pino será utilizado, portanto troque o valor de 6 para um dos pinos que o LM293D está conectado na Intel Galileo Gen2.

Após a inicialização do PWM são declaradas duas variáveis para controlar o PWM: a porcentagem de tempo que o sinal ficará em HIGH (duty_cycle) e o período de pulso do PWM (period).

Com as configurações realizadas um laço do tipo FOR é executado infinitas vezes. Nesse laço o PWM é acionado e o código aguarda por 5 segundos. Após esse período é altera a porcentagem de tempo que o sinal fica em HIGH.

Note que a variável duty_cycle é iniciada com zero, o que deixa o motor em estado de repouso. Durante a execução do laço FOR esse valor é incrementado fazendo o motor acelerar. Ao chegar ao valor máximo o motor é desligado na próxima execução do laço e o ciclo se inicia novamente.

Para iniciar o debug do programa clique com o botão direito do mouse sobre o nome do projeto na janela Project Explorer do Eclipse e selecione a opção Debug As -> IoT Eclipse Developer Kit. Será aberta uma janela solicitando a credencial para conexão com a placa. Deixe o campo User ID com o valor root e o campo Password em branco e clique no botão OK. Será iniciada a compilação, transferência do programa para placa e execução do programa.

O motor deverá iniciar o programa em repouso e acelerar até o máximo para em seguida parar novamente. Para encerrar o programa selecione o menu Run -> Terminate.

Nesse ponto montamos nosso ambiente para desenvolvimento em C++ e validamos esse ambiente com a execução de um programa de teste. Mais informações sobre o uso do Eclipse pode ser encontrada na documentação do IDE, além de tutoriais disponíveis na internet. Também encontramos diversos tutoriais das linguagens C e C++ na internet.

Onde encontrar:

Obrigado a todos e até o próximo post!

Usando outras linguagens na placa Intel Galileo

Olá a todos,

comentamos em um post anterior que é possível desenvolvermos projetos em C++ ou Node .JS utilizando nossa placa Intel Galileo e também executar diversos programas ao mesmo tempo.

Mesmo quando escrevemos nossos programas em outras linguagens podemos utilizar os pinos da nossa placa de forma semelhante quando escrevemos nossos skecths. Para controlar os pinos da Intel Galileo Gen2 devemos utilizar as bibliotecas libmraa e UPM. Essas bibliotecas já estão presentes na imagem que montamos em outro post.

A biblioteca libmraa permite controlarmos os pinos diretamente de forma simples, assim como fazemos em nossos sckecths. Ela possui interfaces para desenvolvermos nossos programas em C++, Javascript, Phyton e Java. A documentação da biblioteca libmraa é encontrada no link http://iotdk.intel.com/docs/master/mraa/.

A biblioteca UPM (Usefull Packages & Modules – Pacotes e módulos úteis) possui classes prontas para lidarmos com uma grande quantidade de sensores e motores e outros componentes, simplificando o desenvolvimento de nossos programas. Dessa forma podemos utilizar uma classe para controlar algum componente ao invés de manipularmos os pinos, o que nos salva tempo para aprendermos a lidar com o componente, desenvolver o código e testá-lo.

A lista completa dos sensores suportados pela biblioteca UPM é encontrada no link: http://iotdk.intel.com/docs/master/upm/modules.html. Já a documentação da biblioteca é encontrada no link https://github.com/intel-iot-devkit/upm/.

Veremos nos próximos post como devemos montar nosso ambiente de desenvolvimento para escrevermos aplicações em C++ ou Node .JS para utilizarmos em nossos projetos com a placa Intel Galileo

Um abraço e até o próximo post!

Conectando a placa Intel Galileo via rede Wifi

Olá a todos,

nesse post demonstraremos como podemos conectar a placa Intel Galileo Gen2 na nossa rede Wifi. Podemos realizar essa conexão por dois modos:

Utilizando shields WIFI do padrão Arduino
Por meio de uma placa Wifi mini PCI utilizada em notebooks

O uso de um shield Arduino de Wifi possui a vantagem de utilizarmos o padrão Arduino de conexão, porém limitados o uso da conexão apenas aos sketchs, que são os programas desenvolvidos na linguagem do Arduino. Além disso, toda vez que nossos sketchs iniciarem o objeto de WiFi será iniciada a conexão de rede o que consome algum tempo.

Já o uso da placa de Wifi mini PCI possui a vantagem de podermos utilizá-la em todas as linguagens de programação disponíveis para a Intel Galileo Gen2 e a conexão de rede é estabelecida quando a placa é ligada. Outro beneficio do uso da placa mini PCI no lugar de um shield é a redução de espaço que em alguns casos pode ser crucial.

Para adicionar uma conexão WiFi na Intel Galileo com o uso da placa Mini PCI precisaremos acessar o terminal do Yocto, cujo procedimento está descrito no post anterior. Além dos itens mencionados naquele post precisaremos:

Placa Intel Centrino Wireless-N 135;
Adaptador da placa mini PCI;
Um par de antenas de lap top.

O primeiro passo é montarmos o adaptador na placa mini PCI. Fixe o adaptador na placa com o uso dos parafusos que acompanham o adaptador:

Em seguida conecte as antenas de laptop nos terminais da placa mini PCI. Para encerra a instalação da placa insira os terminais da placa mini PCI no slot mini PCI que está no verso da placa e encaixe os furos do adaptador nos encaixes da placa:

Com a montagem física concluída, ligue a Galileo Gen2 na energia e no roteador com o cabo e inicie uma sessão SSH como mostrado no post anterior. Após iniciada a sessão execute o comando connmanctl. Note que o prompt do terminal foi alterado. Inicie a placa de WiFi com o comando enable wifi e em seguida realize a procura da sua rede com o comando scan wifi.

Para listar as redes identificadas utilize o comando services. Será exibida no terminal uma lista com o nome das redes encontradas e um identificador para cada uma.

Comandos para habilitar a interface Wifi

Caso a rede que você deseja conectar sua placa possua senha execute o comando agent on. A conexão com a rede é realizada com o comando connect <ID da rede>. Você não precisa digitar todo o ID da rede, somente os primeiros caracteres e em seguida pressione TAB para o Linux completar o texto. Ao entrar com o comando será solicitada a senha.

Com a conexão estabelecida digite o comando exit para encerrar o connmanctl. Para confirmar que a conexão WiFi foi estabelecida e obter seu endereço IP execute o comando ifconfig. Você poderá utilizar o endereço IP dessa conexão para futuras conexões com o Putty e também em seus programas:

Onde encontrar:

Obrigado a todos e até o próximo post!

Conectando a Intel Galileo Gen2 na rede local

Olá a todos,
nesse post demonstraremos como podemos conectar a placa Intel Galileo na nossa rede local, permitindo a conexão da placa com outros computadores (incluindo o que você está utilizand agora) além de outros dispositivos que estejam expostos na sua rede local.

Com o IDE funcionando poderemos conectar nossa placa na rede e acessar seu terminal Linux remotamente. Para essa atividade você precisará de:

Um cartão micro SD de pelo menos 4GB e no máximo 32GB;
Programa Putty;
Programa 7ZIP instalado em seu computador;
Programa Win32 Disk Imager instalado em seu computador;
Um cabo de rede;
Um roteador;
Que o computador esteja conectado a esse roteador, seja por um cabo ou por Wifi.

O primeiro passo é instalar os programas 7ZIP e Win32 Disk Imager caso seu computador ainda não os possua. Em seguida baixe o arquivo com a imagem do Yocto (distribuição Linux para o Intel Galileo) do site da Intel no endereço http://iotdk.intel.com/images/iot-devkit-latest-mmcblkp0.direct.bz2. Utilize o 7ZIP para extrair o conteúdo do arquivo.

Antes de iniciar a gravação da imagem será necessário formatar o cartão micro SD. Concluída a formatação inicie o Win32 Disk Imager e clique no botão com a pasta azul para selecionar o arquivo com a imagem que extraímos do arquivo bz2. Note que você precisará alterar o filtro de arquivos para o arquivo com a imagem aparecer.

Em seguida selecione a unidade de disco que corresponde ao cartão micro SD na lista que está ao lado do botão com a pasta azul e clique no botão Write. Será iniciada a montagem da imagem no cartão. Aguarde o término do processo.

Com a imagem gravada no cartão desligue sua placa Intel Galileo Gen2 do computador e da energia e insira o cartão no slot. Em seguida conecte a placa na fonte de alimentação, no computador com o cabo USB e no cabo de rede que está conectado no roteador, nessa sequência.

Agora abra o IDE e carregue na placa o programa mostrado na imagem abaixo. Esse programa realiza duas ações:

Inicializa a porta serial e escreve um texto até que você envie o caractere “a” para a placa;
Executa comandos do sistema operacional Linux que inicia a placa de rede local e mostra o status das conexões de rede, além de exibir os resultados no monitor serial. Nesses resultados teremos o endereço IP da placa.

Código para iniciar a rede na Intel Galileo.

Compile e transfira o programa clicando no botão com a seta para a direita. Em seguida abra o monitor serial e envie o caractere ‘a’ para que sejam exibidos os dados das conexões de redes. Localize na resposta o endereço IP que o roteador atribuiu à placa e anote esse valor.

Para conectar no terminal do Yocto devemos utilizar um programa que realiza conexões do tipo SSH. Um desses programas é o putty. Insira o endereço IP da placa e clique no botão Open.

Será aberta uma janela terminal do Yocto solicitando um login. O login inicial da placa é o root. Portanto digite root e pressione a tecla enter. Na primeira conexão aparecerá uma mensagem perguntando se você deseja armazenar as chaves de acesso dessa conexão. Clique em Yes.

Será aberta uma sessão do terminal do Yocto. Execute alguns comandos Linux para explorar o ambiente.

Onde encontrar:

Obrigado a todos e até o próximo post!

Montando o ambiente de desenvolvimento para o Intel Galileo Gen2

Olá a todos,

nesse post mostraremos como montar o ambiente de desenvolvimento para utilizarmos a nossa placa Intel Galileo Gen2. Esse post foi baseado nas instruções do site da Intel.

Para iniciar o usa da placa você precisará também dos seguintes itens:

Cabo USB para micro USB;
IDE de desenvolvimento para o Arduino

Quando ligamos a placa devemos sempre realizar as etapas na seguinte seqüência:

Conecte a fonte de alimentação na tomada;
Conecte a fonte de alimentação na Intel Galileo Gen2;
Conecte o cabo USB no computador e na placa.

Essa sequência é importante pois a porta USB não possuí potência suficiente para alimentar a placa, podendo queimar a porta USB do computador ou da placa.

O próximo passo será instalar o IDE (software para escrever os programas Arduino), que pode ser baixado no site da Intel. Devemos do prestar atenção para baixarmos a versão correta para o sistema operacional (Windows, Linux ou Mac OS), se ele é 32bits ou 64bits pois esse detalhe fará diferença durante a instação dos drivers.

Após a instalação do IDE devemos configurar a placa e a porta em que ela está conectada para que seja possível a correta compilação e transferência do programa. Essa configuração é semelhante quando utilizados versões de Arduino e já foi mostrado em outro post.

Assim que a configuração da placa e da porta estiverem corretas podemos compilar e transferir os programas para a placa, conforme mencionado no post já mencionado.

A partir desse ponto podemos escrever programas na linguagem utilizado pelos Arduinos e utilizá-los em nossa placa Intel Galileo Gen 2. Nos próximos post demonstraremos como preparar o ambiente para escrevermos nossos programas em C++ e Node .JS

Onde encontrar:

Obrigado a todos e até o próximo post!

A Placa Intel Galileo Gen2

Olá a todos,

nesse post falaremos sobre a placa Intel Galileo Gen2 que é compatível com o padrão Arduino. Isso significa que podemos utilizar a linguagem de programação padrão disponível no site arduino.cc para escrevermos nossos programas, que são chamados de sketch, e transferi-los para a placa como já demonstrado nos post anteriores.

Porém também é possível desenvolvermos nossos programas em outras linguagens como C++, Node.JS e Phyton, além de combinar diversos programas mesmo em linguagens diferentes para compor nossos projetos e executá-los ao mesmo tempo. Esse assunto será coberto e um post futuro.

Outro item do padrão Arduino é a pinagem da placa que deve seguir a especificação em relação aos pinos disponíveis e a distribuição física dos mesmos. Essa padronização permite que possamos utilizar as placas complementares para Arduino conhecidas como Shields que se encaixam nos pinos da Galileo Gen2. Dessa forma podemos estender as funcionalidades da nossa placa adicionando Shields drivers, relés, sensores, etc.

Vamos entender agora quais são os pinos e conexões disponíveis do Galileo Gen2:

Podemos ver na placa uma caixa retangular metálica que possui um conector de rede. Esse conector é uma ethernet que pode ser utilizada para conectarmos nossa placa na rede local. Ao lado desse conector temos uma porta micro USB e uma porta USB. A porta micro USB será utilizada para transferir os programas para a placa enquanto a porta USB padrão pode ser utilizada para conectar diversos dispositivos, como uma webcam, que podem ser controlados por nossos programas.

Na sequencia temos os pinos digitais padrão Arduino, que são nomeados de 0 a 13. Note que os pinos 0 e 1 estão marcados com RX e TX, pois podemos utilizar esses pinos para realizar comunicação serial entre a placa e outros dispositivos ou mesmo entre placas padrão Arduino. Outra marca presente em alguns dos pinos é um til (“~”). Essa marca no pino indica que ele suporta o uso de PWM. Veremos mais adiante o que significa PWM e como trabalhar com ele.

Na lateral esquerda temos o conector de energia onde conectaremos a fonte externa, mas podemos conectar também uma bateria 12V. Abaixo desse conector temos a entrada para cartões micro SD que utilizamos para persistir nossos programas na placa e também para utilizar recursos mais avançados como desenvolvimento em C++ ou Node.JS ou uso do WiFi e bibliotecas avançadas, como reconhecimento de imagens.

Na parte inferior da figura temos os pinos analógicos, nomeados de A0 a A5. Esses pinos são utilizados para medirmos valores analógicos de sensores ou outras partes do circuito para utilizamos nos nossos programas. Também temos nessa linha de pinos os pinos de alimentação. Os principais pinos nessa linha são os marcados com GND também conhecidos como terra e os pinos 5V e 3,3V que podem ser utilizados para alimentar nossos circuitos com essas tensões.

No verso da placa temos um conector mini PCI que pode ser utilizado para adicionarmos módulos desse padrão na nossa placa, como placa de comunicação WiFi e Bluetooth.

Nos proximos post demonstraremos como utilizar a placa Intel Galileo Gen2, como gravar a imagem do sistema operacional no cartão SD, programar a placa nas diversas linguagens, utilizar a conexão de rede por cabo e wifi além de controlar uma webcam.

Onde encontrar:

Obrigado a todos e até o próximo post!