abril 2016 – 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!

Controlando motores DC com o Arduino

Olá a todos,

nesse post aprenderemos como utilizar motores DC em nossos projeto com Arduino. Os motores DC são utilizamos em robôs ou brinquedos de radiocontrole para movimentá-los. Porém esses motores consomem mais potência do que os pinos de controle do Arduino podem fornecer e por esse motivo não podemos conectar os motores diretamente nos pinos digitais do Arduino.

Para contornar esse problema utilizamos drivers de potência que são circuitos que permitem que um sinal de baixa potência controle o fluxo de energia de uma fonte de alta potência. Podemos construir esse tipo de circuito com o uso de transistores, mas existem circuitos integrados (CIs) que já possuem esses circuitos montados.

No nosso circuito utilizaremos um CI chamado L239D que é um circuito driver de potencia chamado de ponte H. Esse tipo de circuito permite controlarmos um motor DC nos dois sentidos (horário e anti-horário). A velocidade do motor poderá ser controlada pelo uso da técnica de PWM onde a velocidade do motor será proporcional a largura do pulso.

O CI L239D possui dois circuitos ponte H que suportam até 36V e 1A, portanto é possível controlarmos dois motores DC com até essa potência com apenas um L239D. Os pinos do L239D devem ser contados como na figura abaixo:

O primeiro passo é conectarmos os terminais 4, 5, 12 e 13 do L293D no terra (GND) do Arduino e em seguida os terminais 1, 8, 9 e 16 também do L293D no pino 5V do Arduino. Agora conecte os terminais 2 e 7 do CI nos pinos do Arduino que controlarão o giro do motor (horário e anti-horário). Para finalizar conecte os pinos do motor nos terminais 3 e 6 do L293D.

Abaixo temos o esquema elétrico e o desenho elaborado no simulador:

Passaremos agora para o código que controlará o motor DC.

O primeiro passo é declarar as constantes que indicarão os pinos do Arduino que controlarão o motor. Na sequência configure esses pinos como saída, com a função pinMode utilizando a constante OUTPUT. Deixe o motor parado deixando os dois pinos em estado LOW. Encerre a inicialização do programa configurando a porta serial:

Passaremos para o desenvolvimento da função loop, que fará a leitura da porta serial e controlará a rotação do motor DC. O primeiro passo é verificar com o método available se há caracteres para serem lidos da porta serial. Caso não exista caracteres na porta serial o programa deve aguardar 300 milissegundos e encerrar essa execução da função loop com o comando return.

Existindo caracteres para serem lidos, deveremos utilizar o método read para obtê-los. Caso tenha sido enviado o caractere A, deixaremos um dos pinos em estado LOW, e no outro pino utilizaremos o PWM com valor 128 para o motor girar em um sentido. Quando for enviado o caractere L faremos ação contrária e o motor girará no outro sentido. Ao enviarmos o caractere de espaço em branco deixaremos os dois pinos com valor LOW para parar o motor.

Compile o código, transfira o programa e acesse o monitor serial. Envie um caractere A ou L para fazer o motor girar em um sentido. Envie o caractere espaço para fazer o motor parar. Se desejar altere o valor do PWM de 128 para outro valor para alterar a velocidade do motor.

Onde encontrar alguns dos componentes:

Obrigado pela atenção e até o próximo post!

Controlando servo motores com o Arduino

Olá a todos,

neste post aprenderemos utilizar servos motores em nossos projetos. Servos motores são dispositivos que permitem controlarmos com precisão a posição do seu eixo. A posição do eixo de um servo é controlada com o uso do PWM, onde a largura do pulso HIGH informa a posição do servo. Existem servos que permitem a rotação de 90°, 180°e até 360°de seu eixo. Servos são muito utilizados em robôs e brinquedos de radio controle, como carrinhos e drones.

Controlaremos a posição do servo enviando comandos pela porta serial, assim quando enviarmos o caractere A o servido deslocará o eixo um grau no sentido anti-horário e ao enviarmos o caractere S o servo deslocará o eixo um grau no sentido horário.

Ao contrário dos post apresentados até o momento não será necessário a montagem de um circuito na protoboard, pois o servo utilizado nesse exemplo possui um conector que se encaixa no cabo macho-macho. Simplesmente conecte o fio do terra do servo em um pino terra (GND) do Arduino, o fio do VCC do servo no pino 5V do Arduino e o fio que sobrará em um pino digital do Arduino que suporte o uso de PMW.

Abaixo temos o esquema elétrico e o desenho elaborado no simulador:

Diagrama da montagem do Servo no Arduino

Passaremos agora para o desenvolvimento do programa que controlará o servo. O primeiro passo é utilizarmos o comando #include para incluirmos a biblioteca Servo.h que possui o objeto e métodos para trabalharmos com servo motores. Essa biblioteca disponibiliza métodos mais simples para trabalhar com os servos, como o método write que recebe o grau que queremos o eixo do servo seja movido ao invés do comprimento do pulso.

Em seguida declare um objeto do tipo Servo para controlarmos o servo e uma variável do tipo inteiro para armazenar o ângulo que o eixo estará. Em seguida escreva na função setup a inicialização do objeto Servo com o método attach. Esse método recebe o pino que o servo está conectado. Os valores de comprimento mínimo e máximo do pulso devem ser obtidos na documentação do servo. Inicie também na função setup a porta serial.

Na função loop verifique se há caracteres para serem lidos na porta serial. Caso não exista caracteres para serem lidos o programa aguardará 300 milissegundos e terminará esse execução da função loop com o comando return.

Existindo caracteres na porta serial, estes deverão ser lidos. Quando o caractere enviado for A a variável com os graus da posição do eixo será incrementada em uma unidade e quando for enviado o caractere S essa variável será decrementada em uma unidade. Após o cálculo da nova posição ela será enviada e o eixo do servo será movimentado. Por fim a função aguarda 300 milissegundos para verificar novamente a porta serial.

Onde encontrar alguns dos componentes:

Obrigado pela atenção e até o próximo post!

Utilizando display de LCD com o Arduino

Olá a todos,

Até o momento utilizamos a porta serial do Arduino em conjunto com o monitor serial do IDE para recebermos mensagens dos nossos programas como a temperatura ou a intensidade de luz do ambiente. Nesse post aprenderemos como utilizar um display de cristal liquido para dispensar o uso do cabo USB e do computador.

Nesse exemplo utilizaremos um display LCD de 2 linhas e 16 posições por linhas, mas existem outros modelos disponíveis no mercado. Para esses outros modelos é importante você consultar o datasheet, que normalmente está disponível na internet, para verificar as conexões necessárias.

Para montarmos o circuito coloque o display na protoboard e também um potenciômetro. O potenciômetro será utilizado para controlarmos o brilho do LCD. Em seguida ligue o terminal da esquerda do potenciômetro no terra (GND) do Arduino e no terminal 1 do display (o terminal mais próximo da borda do LCD). Conecte também no terra os terminais 5 e 16 do LCD.

Agora conecte o pino de 5V do Arduino no terminal da direita do potenciômetro e também nos pinos 2, 11 e 15 do LCD. Conecte o terminal 3 do LCD no terminal central do potenciômetro.

O próximo passo é conectar o terminal 4 do LCD no pino 12 do Arduino e o terminal 6 do LCD no pino 11 do Arduino. Conecte também os terminais 11, 12, 13 e 14 do LCD nos pinos 5, 4, 3 e 2 do Arduino respectivamente. Revise todas as conexões utilizando a imagem e os diagramas do circuito que estão abaixo:

Abaixo temos o esquema elétrico e o desenho elaborado no simulador:

Passaremos agora para o desenvolvimento do programa que receberá textos pela porta serial e exibirá esses textos no LCD.

O primeiro passo é incluir no nosso programa o arquivo com as funcionalidades do LCD através do comando #include < LiquidCrystal.h >. Esse comando importa todas as funcionalidades existentes do arquivo informado para o nosso programa.

Importado o arquivo o próximo passo será a declaração de um objeto do tipo LiquidCrystal para operarmos o LCD e de uma variável inteira para controlar em qual linha do LCD escreveremos a mensagem. Note que no construtor do objeto do tipo LiquidCrystal devem ser informados os pinos do Arduino que estão conectados ao LCD.

O objeto do tipo LiquidCrystal possui métodos que facilitam o uso do LCD dispensando a necessidade de controlar diretamente os pinos do Arduino.

Em seguida escreva na função setup a configuração do LCD com uso do método begin. Nesse método devem ser informadas a quantidade de colunas e quantidade linhas do display. Escreva também na função setup a configuração da porta serial.

Passaremos para o desenvolvimento da função loop. O primeiro passo é verificarmos a quantidade de caracteres disponíveis na porta serial com o método available. Note que no programa foi limitada a quantidade de caracteres em 16 para evitar estouros na linha do LCD.

Em seguida declare uma variável do tipo String. Esse tipo de variável representa uma cadeia de caracteres, ou seja, um texto. O próximo passo é ler os caracteres disponíveis na porta serial com o método read e adicionarmos esses caracteres na variável String. Como o método read do objeto Serial lê apenas um caractere por vez colocamos esse trecho de código em uma laço do tipo FOR para lermos todos os caracteres.

Com o texto na memória do programa vamos primeiro escrever no LCD uma linha em branco para limpar a mensagem anterior para em seguida escrever a nossa mensagem. Ambas as instruções são executadas com o método print. Note que sempre na sequência da chamada do método print utilizamos o método setCursor para ajustarmos o cursos na posição no início da linha.

O método setCursor recebe dois parâmetros: o primeiro é o índice da coluna onde desejamos escrever o próximo caractere e o segundo parâmetro é o índice da linha do display onde o texto será escrito.

O último passo é alterarmos a variável que controla linha do display para na próxima execução da função loop o programa escrever na outra linha. Caso deseje limpar a próxima linha basta pressionar o botão Send do monitor serial para enviar um texto em branco.

Compile e transfira o programa para o Arduino. Após o programa iniciado acesse o monitor serial, digite algum texto e pressione o botão Send. O texto deverá aparecer no LCD, mas caso nada apareça mexa na haste do potenciômetro para alterar o brilho do texto.

Onde encontrar alguns dos componentes:

Obrigado pela atenção e até o próximo post!