Bot Telegram com a Beaglebone Black

A BeagleBone Black tem inúmeras utilidades para projetos. Com ela é possível fazer praticamente qualquer projeto envolvendo rede, internet ou até alguns que funcionem isoladamente. Independente do projeto a ser realizado, deve existir alguma interface com o usuário (seja por teclado, display, socket, etc.). Neste post vamos montar um Bot Telegram com Beaglebone Black, um sistema de monitoramento por imagens de webcam que utiliza o serviço de mensagens instantâneas Telegram.

Este projeto foi baseado neste excelente projeto do André Curvello.

Materiais necessários

Para a realização deste projeto você vai precisar de:

• Placa BeagleBone Black Rev. C
• Webcam USB (convencional)
• Um ponto cabeado de acesso à Internet

O que é o Telegram

O Telegram é um serviço de mensagens instantâneas multi-plataforma totalmente grátis (e open-source!). Isso significa que pode ser usado no Windows Desktop, iOS, Android, Windows Phone, Linux e por aí vai. É um dos concorrentes do famoso WhatsApp.

Em relação ao seu rival WhatsApp, o Telegram possui como principal vantagem disponibilizar APIs para integração. Ou seja, é possível facilmente um desenvolvedor integrar sua aplicação com o Telegram, aumentando assim o potencial de suas soluções.

O site oficial do Telegram é: https://telegram.org/

Fazendo uma webcam funcionar na BeagleBone Black

Uma vez  que a BeagleBone Black tem acesso à Internet, é necessário instalar o programa fswebcam. Para isto, utilize o seguinte comando no terminal da BeagleBone Black:

apt-get install fswebcam

Com o fswebcam instalado, coloque a webcam na porta USB da BeagleBone Black e execute os seguintes comandos no terminal:

cd /dev
ls

Irá aparecer uma listagem de todos os devices presentes / possíveis detectados pelo Linux da BeagleBone Black. Se a sua webcam for compatível com o Linux, o device video0 irá aparecer na listagem, conforme ilustra a imagem a seguir:

Uma vez comprovado que sua webcam é compatível com Linux, é chegada a hora de testar o programa fswebcam. Para isso, execute os seguintes comandos:

cd ~
fswebcam Teste.jpg

A mensagem da figura a seguir irá surgir e um arquivo chamado Teste.jpg contendo a foto da webcam será criado na pasta home.

Se tudo funcionou como descrito, a sua webcam está funcionando perfeitamente para tirar fotos no Linux da BeagleBone Black!

Bot Telegram – como fazer?

Para fazer um bot Telegram é preciso, primeiramente, baixar o Telegram em seu dispositivo móvel (ou utilizar sua versão web, caso estiver utilizando um PC).

Uma vez baixado / utilizando o Telegram, inicie uma conversa com o BotFather (se estiver utilizando via web no computador, basta acessar este link: https://telegram.me/botfather) e seguir as instruções. É realmente simples!

Ao fim do processo, seu bot está criado e pronto para entrar em ação. O processo resultará também em um Token / código, dado único para cada bot Telegram. Deixe este Token salvo em algum local seguro, você irá precisar dele mais pra frente neste projeto.

Transformando a BeagleBone Black em um bot Telegram

Chegou a hora de transformar a BeagleBone Black em um bot Telegram. Para isto, é preciso que a mesma tenha acesso à Internet e, preferencialmente, que você tenha acesso à BeagleBone Black via SSH. Para isto, recomendo seguir este tutorial do blog FilipeFlop.

Antes de partir para o programa, execute o comando abaixo que vai carregar o pacote para uso do Telegram dentro do programa em Python:

pip install python-telegram-bot

O bot Telegram BeagleBone em questão tem duas funcionalidades:

• Servir de interface para o usuário “conversar” com a BeagleBone para solicitar uma foto da webcam
• Identificar a solicitação do usuário e, quando identificar o pedido de envio de foto, tirar uma foto e enviar.

O código-fonte do projeto pode ser visto a seguir.

#Bot de Telegram com a BeagleBone Black
#Autor: Pedro Bertoleti
#Data: 11/2016
#Importante: Este codigo foi feito com referencia ao artigo
#http://www.embarcados.com.br/bot-com-telegram-na-intel-edison/ , 
#do autor Andre Curvello

#imports necessarios:
import telegram			
import os
from time import sleep 
import urllib2
import json

#imports de bibliotecas para tratar erros de conexao URL.
try:
    from urllib.error import URLError
except ImportError:
    from urllib2 import URLError

#variaveis globais:
TokenBotTelegram = ' '  #coloque aqui o token do seu bot Telegram	


#Funcao: Trata mensagem recebida / interpreta mensagem do usuario
def TrataMensagem(MsgRecebida,chat_id):
   MsgRecebidaLC = MsgRecebida.lower()
   
   if "oi" in MsgRecebida:
       print "[USUARIO]: requisicao de contato"
       bot.sendMessage(chat_id=chat_id, text='Ola! Tudo bem? O que voce deseja?')

   if  "foto" in MsgRecebida:
       print "[USUARIO]: requisicao de foto"
       os.system("fswebcam FotoTelegram.jpg")
       bot.sendMessage(chat_id=chat_id, text='Foto:')
       bot.sendPhoto(chat_id=chat_id, photo=open('FotoTelegram.jpg','r'))   

#Funcao: executa a comunicacao da BeagleBone Black com o Telegram
def ExecutaBeagleBoneBot(bot, update_id):
    for update in bot.getUpdates(offset=update_id, timeout=10):
        
        #o chat_id eh a id do chat de comunicacao Telegram
        #eh necessaria para o bot identificar a conversa.
        chat_id = update.message.chat_id
	
        #atualiza o indice update_id - para ref novas mensagens
        update_id = update.update_id + 1
	
        #captura a mensagem de texto enviada ao bot no dado chat_id
        message = update.message.text

        if message:
            #Se chegou ate aqui, significa que ha uma mensagem para ser tratada. 
            #Portanto, faz o tratamento da mensagem recebida e envia a resposta pelo Telegram
            TrataMensagem(message,chat_id)

    # retorna o ultimo update_id para servir de referencia
    return update_id
	
#------------------	
#Programa principal
#------------------   

#Variavel update_id (usada pelo Telegram)
update_id = None

#Inicializacao do Bot
bot = telegram.Bot(TokenBotTelegram)
print '[BOT] Bot Telegram iniciado. Aguardando comandos.'

while True:
   try:
       try:
           update_id = ExecutaBeagleBoneBot(bot, update_id)
       except telegram.TelegramError as e:
           #Se ocorrer algum problema (como lentidao, por ex):
           if e.message in ("Bad Gateway", "Timed out"):
                sleep(1) 
           else: 
                raise e
       except URLError as e:
           #Ha problemas de rede
           sleep(1)
   except KeyboardInterrupt:
        print "Ctrl+c pressionada. A aplicacao sera encerrada."
        exit(1)

Para colocá-lo na BeagleBone Black, faça o seguinte procedimento:

1 – Copie o código-fonte

2 – Digite o seguinte comando

nano BotTelegramFoto.py

3 – Cole o código-fonte no editor utilizando o botão direito do mouse

4 – Coloque seu Token do bot Telegram no local indicado

5 – Pressione Ctrl + X e responda SIm / Yes para as perguntas do editor

6 – Execute o programa com o seguinte comando:

python BotTelegramFoto.py

Feito isso, basta entrar no Telegram e conversar com seu bot! Para isso, utilize as seguintes mensagens / comandos:

• oi : Inicia uma conversa com o bot. Este responderá com uma saudação. Este comando serve para verificar se o bot está no ar.
• foto : Solicita que a BeagleBone Black tire uma foto pela webcam e a envie para você pelo Telegram. Este procedimento demora alguns segundos.

Resultado

As imagens a seguir mostram o resultado da execução (tanto na interface web do Telegram quanto no terminal da BeagleBone Black.

Gostou ? Ajude-nos a melhorar o blog atribuindo uma nota a este tutorial (estrelas no final do artigo), comente e visite nossa loja FILIPEFLOP!

Site: Blog FILIPEFLOP

Conheça a Asus Tinker Board

No post de hoje vamos apresentar a Asus Tinker Board, uma placa que claramente veio para “brigar” com a Raspberry Pi,  e você vai entender isso ao longo do post.

A Asus Tinker Board

A placa Asus Tinker Board é uma placa do segmento SBC (Single Board Computer), e se à primeira vista você achou ela parecida (senão igual) à Raspberry Pi, não é por acaso: o tamanho da placa é o mesmo, assim como a distribuição dos conectores. Conseguimos inclusive usar com a Tinker Board a mesma case para Raspberry Pi que temos na loja:

Podemos ver que temos os mesmos conectores USB 2.0, o adaptador ethernet, áudio, HDMI, alimentação (5V 2.5A recomendado) e até os conectores na placa para display e câmera:

A diferenciação fica por conta do conector GPIO, que tem um interessante esquema de cores para ajudar na conexão de dispositivos, afinal, quem nunca ficou contando os pinos para descobrir qual era o GND, não é verdade ? Na Tinker Board, basta procurar o pino identificado com a cor preta para encontrar o GND, o vermelho para Vcc 5V, o amarelo para Vcc 3.3V e o azul para a interface I2C:

As diferenças não param por aí, porque internamente a Tinker Board é uma placa com uma configuração mais robusta, voltada para pessoas que desejam extrair mais de uma single board computer. O processador é um ARM Rockchip RK3288 quad-core (32 bits) rodando à 1.8 GHz, e na Tinker Board temos 2GB de memória LPDDR3. A placa também é equipada com uma interface SDIO 3.0, que melhora significativamente a velocidade de acesso ao cartão microSD usado pelo Sistema Operacional.

Mas talvez a melhor característica da Tinker Board esteja mesmo na GPU, a unidade de processamento gráfico. Graças à GPU ARM Mali T764, a Tinker Board promete rodar vídeos e jogos em alta resolução (inclusive vídeos em 4K), sem travamentos. Isso significa que projetos como streaming, visão computacional, reconhecimento de gestos, processamento e tratamento de imagens podem aproveitar todo o potencial da placa, que fornece suporte à H.264 e H.265, rodando vídeos em HD e UHD.

Na parte de áudio, temos um conector que suporta ao mesmo tempo saída de áudio e microfone, podendo reproduzir áudio até 192kHz/24-bits, sendo que essa também é uma característica interessante e que geralmente deixa a desejar em outras placas do segmento.

Conectividade da Tinker Board

Com relação à conectividade, uma boa notícia para quem precisa de velocidade de comunicação ethernet: na Tinker Board, ela é Gigabit, trazendo um rendimento muito superior comparado às conexões 10/100 tradicionais. Além do incremento de velocidade, a arquitetura da Tinker Board agrega outras melhorias de performance e confiabilidade na conexão ethernet.

Tem Wifi e Bluetooth ? Tem sim, os dois em um único chip, com o adicional que a antena usa um conector IPEX. Assim, se você desejar (ou precisar), pode desconectar a antena onboard e conectar uma antena externa, aumentando o alcance do wireless da sua Tinker Board.

Instalação do sistema Operacional e considerações finais

Na Tinker Board que testamos (rev. 1.2) instalamos o Sistema Operacional disponível no site da Asus, o TinkerOS (download), que é uma distrbuição Linux Debian, semelhante à usada no Rasbperry Pi.

Quem já instalou o sistema operacional no Raspberry, no entanto, vai sentir falta de uma tela de instalação mais informativa. No caso da placa da Asus, copiamos a imagem para o cartão microSD,  conectamos a alimentação e tivemos que aguardar alguns minutos para que a instalação fosse finalizada. Esse tempo de espera dá a impressão de que a imagem não foi copiada corretamente e apresentou algum erro, mas é só aguardar para ser apresentado à tela principal do SO.

Em questão de performance, a Asus Tinker Board se mostrou suficientemente rápida para ser utilizada como um PC “comum”, sem grandes gargalos para utilização do browser (Chromium) e demais tarefas do sistema operacional, que ainda é bem enxuto, logo você não vai encontrar programas pré-instalados como o Minecraft, LibreOffice e outros pacotes disponíveis no Raspbian.

Com relação à parte gráfica, rodamos vídeos do youtube sem gargalos até a resolução de 720p. Depois disso, tivemos uma certa dificuldade talvez por exigir demais do hardware, já que o processador da Tinker Board esquentou bastante durante o uso, sendo altamente recomendável o uso de dissipador e cooler durante a operação.

De forma geral a performance da Tinker Board agradou, e a Asus continua trabalhando para que a placa funcione com versões do Linux como Ubuntu e OpenSUSE, mas é um hardware que ainda se encontra em estágio inicial de desenvolvimento e vai demorar um pouco até que ela alcance o patamar da Raspberry Pi em termos de documentação disponível, suporte ao produto e envolvimento da comunidade. Hardware para isso a placa tem, vamos aguardar o empenho do fabricante para que isso ocorra.

Gostou ? Ajude-nos a melhorar o blog atribuindo uma nota a este tutorial (estrelas no final do artigo), comente e visite nossa loja FILIPEFLOP!

Site: Blog FILIPEFLOP

Como usar a IDE Arduino na Linkit Smart 7688 Duo

Neste artigo iremos tratar de como preparar o ambiente de desenvolvimento para criar projetos utilizando a Linkit Smart 7688 Duo com IDE Arduino. Se você se interessou por este artigo, assumo que você já conheça a Linkit Smart Duo! Caso ainda não a conheça não se preocupe, abaixo deixarei duas referências abordando sobre uma introdução e outro relatando sobre os primeiros passos com a Linkit.

Antes de começar, caso seja o seu primeiro contato com a Linkit Smart 7688 Duo, recomendo os dois conteúdos abaixo:

• Linkit Smart 7688 Duo – Uma placa 2 em 1
• Primeiros passos com a Linkit Smart 7688 Duo

Material necessário

• Linkit Smart 7688 Duo
• Cabo micro usb
• 1 Led
• 1 resistor 100ohm
• Jumpers macho-macho

Preparando a IDE do Arduino

Para programar o ATMega, utilizaremos a própria IDE do Arduino, pois como mencionado no artigo citado, o modelo do microcontrolador é o mesmo daquele utilizado no Arduino Leonardo, o ATMega32u4.

A integração da IDE vai soar bem familiar para vocês, visto que segue praticamente os mesmos passos para integrar a ide pro esp8266 / nodemcu, mudará somente a url informada.

Portanto para de fato realizar a integração, você deverá abrir sua IDE Arduino (estou utilizando a última versão que consta no site até o momento de lançamento deste artigo: 1.8.1) e posteriormente ir até as preferências da IDE. Observe a imagem abaixo a qual ilustra a tela que deverá abrir para você:

Observe as últimas linhas da imagem, procure pelo seguinte texto: Additional Boards Manager URL’s. Observe que na minha IDE já consta alguma url, que no caso se refere a da Linkit Smart.

Para realizar a adição de uma URL clique ao botão ao lado, uma pequena janela se abrirá para você colocar a url referente à Linkit. Veja na tela abaixo como deverá ficar:

Veja que possui duas URLS na lista, uma referente ao esp8266 e outra referente à Linkit. Para realizar a adição basta adicionar a seguinte url: http://download.labs.mediatek.com/package_mtk_linkit_smart_7688_index.json.

Com isso você terá meio caminho andado, faltará apenas instalar as ferramentas para que de fato a integração esteja pronta.

O próximo passo será abrir o gerenciador de placas da IDE, o item referido fica localizado a parir do menu: Tools -> Board -> Bords Manager. Seguindo este caminho, uma tela se abrirá para você com uma lista de placas disponíveis. Terá um campo de pesquisa, digite “linkit” para realizar um filtro na lista. Você deverá ver algo parecido com o da imagem abaixo:

No meu caso ela já estará instalada, mas para você aparecerá o botão para instalar, apenas clique nele e aguarde alguns instantes (nesta fase dependerá da velocidade de sua conexão com a internet, pois neste momento será efetuado o download de todas as ferramentas necessárias para programar o ATMega).

Terminada a instalação, agora na sua lista de placas você poderá observar que possui uma nova plaquinha: Nossa Linkit Smart :). Então neste momento temos a IDE pronta para podermos fazer algo com o ATMega.

Circuito Linkit Smart 7688 Duo

Como será feito um simples blink, o circuito não terá nenhum mistério. Confira na imagem abaixo como o mesmo ficará:

Realizando o primeiro Blink

Para fazer o blink, apenas abra o Exemplo localizado em sua IDE, ele se encontra no seguinte caminho: File -> Examples -> 01. Basics -> Blink. Apenas será mudado o pino em que o led estará conectado. Portanto veja como deverá ficar seu Sketch:

/*
  Blink
  Turns on an LED on for one second, then off for one second, repeatedly.

  Most Arduinos have an on-board LED you can control. On the UNO, MEGA and ZERO 
  it is attached to digital pin 13, on MKR1000 on pin 6. LED_BUILTIN is set to
  the correct LED pin independent of which board is used.
  If you want to know what pin the on-board LED is connected to on your Arduino model, check
  the Technical Specs of your board  at https://www.arduino.cc/en/Main/Products
  
  This example code is in the public domain.

  modified 8 May 2014
  by Scott Fitzgerald
  
  modified 2 Sep 2016
  by Arturo Guadalupi
  
  modified 8 Sep 2016
  by Colby Newman
*/

#define LED_PIN 13

// the setup function runs once when you press reset or power the board
void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_PIN, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(LED_PIN, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);                       // wait for a second
  digitalWrite(LED_PIN, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);                       // wait for a second
}

Realizando Upload para a Linkit Smart

Resolvi tratar este passo num tópico pois nós podemos utilizar duas formas para realizar upload para o atmega da Linkit Smart com IDE Arduino:

• Via cabo usb(modo tradicional);
• Via OTA;

Para realizar o upload da forma tradicional não terá mistério, simplesmente escolha a porta a qual a sua Linkit está conectada e mande ver clicando no botão de Upload. Espere alguns instantes e seu led já estará piscando – Nossa essa foi fácil heim Douglas!

Bem, o primeiro método foi barbada! Agora utilizaremos o segundo método que nos é disponibilizado: OTA (Over-The-Air). OTA nos permite realizar a atualização do firmware sem que haja necessidade do cabo usb estar conectado. É isso mesmo! Neste momento você utilizará a conexão de rede para efetuar este processo.

Para que isso ocorra bem, recomendo que sua Linkit esteja conectada na sua rede wifi. Caso não saiba fazer isso, dê uma conferida no segundo artigo que foi mencionado na introdução.

Portanto caso tudo esteja configurado, no mesmo local onde você selecionou a porta da sua Linkit, você deverá ver uma outra opção: Network ports, e logo abaixo irá aparecer o nome da sua placa seguida do IP de sua Linkit, no meu caso o nome completo é o seguinte: “Linkit Smart 7688 Duo on 192.168.0.130″. Apenas selecione a porta :).

O próximo passo será realizar o upload, a única coisa que será pedido nesta etapa será a senha que você definiu para sua Linkit(relatado no segundo artigo mencionado) – uma caixa de diálogo se abrirá para você digitá-lá. Se sua senha estiver ok, você verá o processo de upload ‘correndo’ no console da sua IDE. No meu caso teve a seguinte saída.

set pinmux spi_s -> gpio

avrdude: Version 6.1, compiled on Sep 27 2016 at 08:17:47
         Copyright (c) 2000-2005 Brian Dean, http://www.bdmicro.com/
         Copyright (c) 2007-2014 Joerg Wunsch

         System wide configuration file is "/etc/avrdude.conf"
         User configuration file is "/root/.avrduderc"
         User configuration file does not exist or is not a regular file, skipping

         Using Port                    : unknown
         Using Programmer              : linuxgpio
         AVR Part                      : ATmega32U4
         Chip Erase delay              : 9000 us
         PAGEL                         : PD7
         BS2                           : PA0
         RESET disposition             : dedicated
         RETRY pulse                   : SCK
         serial program mode           : yes
         parallel program mode         : yes
         Timeout                       : 200
         StabDelay                     : 100
         CmdexeDelay                   : 25
         SyncLoops                     : 32
         ByteDelay                     : 0
         PollIndex                     : 3
         PollValue                     : 0x53
         Memory Detail                 :

                                  Block Poll               Page                       Polled
           Memory Type Mode Delay Size  Indx Paged  Size   Size #Pages MinW  MaxW   ReadBack
           ----------- ---- ----- ----- ---- ------ ------ ---- ------ ----- ----- ---------
           eeprom        65    20     4    0 no       1024    4      0  9000  9000 0x00 0x00
           flash         65     6   128    0 yes     32768  128    256  4500  4500 0x00 0x00
           lfuse          0     0     0    0 no          1    0      0  9000  9000 0x00 0x00
           hfuse          0     0     0    0 no          1    0      0  9000  9000 0x00 0x00
           efuse          0     0     0    0 no          1    0      0  9000  9000 0x00 0x00
           lock           0     0     0    0 no          1    0      0  9000  9000 0x00 0x00
           calibration    0     0     0    0 no          1    0      0     0     0 0x00 0x00
           signature      0     0     0    0 no          3    0      0     0     0 0x00 0x00

         Programmer Type : linuxgpio
         Description     : Use sysfs interface to bitbang GPIO lines
         Pin assignment  : /sys/class/gpio/gpio{n}
           RESET   =  3
           SCK     =  15
           MOSI    =  16
           MISO    =  17

avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.01s

avrdude: Device signature = 0x1e9587
avrdude: erasing chip
avrdude: reading input file "/tmp/sketch.hex"
avrdude: input file /tmp/sketch.hex auto detected as Intel Hex
avrdude: writing flash (32758 bytes):

Writing | ################################################## | 100% 4.61s

avrdude: 32758 bytes of flash written
avrdude: verifying flash memory against /tmp/sketch.hex:
avrdude: load data flash data from input file /tmp/sketch.hex:
avrdude: input file /tmp/sketch.hex auto detected as Intel Hex
avrdude: input file /tmp/sketch.hex contains 32758 bytes
avrdude: reading on-chip flash data:

Reading | ################################################## | 100% 4.26s

avrdude: verifying ...
avrdude: 32758 bytes of flash verified

avrdude done.  Thank you.

Percebeu a ‘dificuldade’ né? Você poderá sempre utilizar este método, eu mesmo venho utilizando  na maioria dos casos, pois é comodo. Tudo isso ocorrerá de forma transparente pois o firmware da linkit já estará preparado para isso. Você simplesmente terá o ‘trabalho’ de selecionar a placa na lista e mandar ver. Simples, prático e eficaz!

Modos de Desenvolvimento

Num ecossistema onde possuímos um 1 Microcontrolador + 1 Microprocessador embarcados na mesma placa nos podemos usufruir de alguns modos de desenvolvimento. Para quem já brincou com Arduino + PC se comunicando via porta serial, Arduino + Firmata + NodeJS, cenários comuns os quais foram citados que você provavelmente algum dia já brincou com eles.

Portanto diante dessas características da linkit, podemos fazer tudo isso na mesma placa – é isso mesmo! Diante do famoso exemplo tratado acima – Blink, iremos utilizar o mesmo conceito, porém será aplicado em outro cenário.

 Modos de desenvolvimento:

• Utilizando somente o ATMEGA
• Comunicação serial
• Firmata
• Bridge

O primeiro cenário já foi tratado, que é programar somente o atmega para que o mesmo trabalhe de forma independente. Neste próximo exemplo será programado o ATMega e também será desenvolvido um Script Python para rodar no lado da Linkit, e ambos se comunicarão via porta serial.

O exemplo será: o script python mandar um comando a cada segundo para o ATMega através da porta serial, e o atmega estará esperando por isso, logo, de acordo com o comando recebido, ligará ou desligará o led.

Sketch Arduino

#define LED_PIN 13

void setup()
{
  Serial.begin(115200); // open serial connection to USB Serial port (connected to your computer)
  Serial1.begin(57600); // open internal serial connection to MT7688AN // in MT7688AN, this maps to device
  pinMode(LED_PIN, OUTPUT);
}

void loop()
{
  int c = Serial1.read(); // read from MT7688AN
  if (c != -1) {
    switch (c)
    { case '0': // turn off D13 when receiving "0"
        digitalWrite(LED_PIN, 0);
        Serial.println("[INFO] LED DESLIGADO");
        break;
      case '1': // turn off D13 when receiving "1"
        digitalWrite(LED_PIN, 1);
        Serial.println("[INFO] LED LIGADO"); break;
    }
  }
}

Para realizar o upload para o atmega basta escolher um dos métodos de upload abordados acima.

Script Python

import serial
import time
 
s = None
 
def setup():
    global s
    # open serial COM port to /dev/ttyS0, which maps to UART0(D0/D1)
    # the baudrate is set to 57600 and should be the same as the one
    # specified in the Arduino sketch uploaded to ATmega32U4.
    s = serial.Serial("/dev/ttyS0", 57600)
 
def loop():
    # send "1" to the Arduino sketch on ATmega32U4.
    # the sketch will turn on the LED attached to D13 on the board
    s.write("1")
    time.sleep(1)
    # send "0" to the sketch to turn off the LED
    s.write("0")
    time.sleep(1)
 
if __name__ == '__main__':
    setup()
    while True:
        loop()

O script python acima deverá ser colocado ‘dentro’ de sua linkit smart, ou seja, você deverá acessar a sua linkit via ssh e depois criar um arquivo, colocar o código acima, salvar e depois executar o script normalmente.

Se tudo der certo, o script inicializará e você deverá observar seu led piscando

OBS: Ambos scripts foram retirados do site oficial e somente adaptados para nosso cenário.

Consideração finais Linkit Smart 7688 Duo

Vimos acima 2 exemplos de acordo com o modo de desenvolvimento: Programando o ATMega e programando ambos chips e comunicando-os via porta serial.

Os modos de desenvolvimento 3 e 4 serão abordados em artigos futuros. O modo 4 é deveras interessante, pois ativando o modo bridge da linkit(MT7688), através do atmega podemos nos conectar diretamente na internet através da rede wifi, bacana concorda? Já efetuei alguns testes com conexão MQTT e funciona muito bem. Mas deixamos este tema para um próximo artigo

Referências

• Arduino IDE;
• Install Arduino IDE with board support package;
• Fritzing, EMF and SVG diagrams;
• MPU-MCU UART Connection;

Gostou do post da Linkit Smart 7688 Duo ? Ajude-nos a melhorar o blog atribuindo uma nota a este tutorial (estrelas no final do artigo), comente e visite nossa loja FILIPEFLOP!

Site: Blog FILIPEFLOP

Concorra a um Kit Automação Residencial

É tarde, você está cansado, já está deitado, as luzes do quarto estão acesas, mas o interruptor está muito longe da cama. Quem nunca esteve nessa situação? Foi pensando nisso que a FilipeFlop escolheu o Kit Automação Residencial com Arduino para o nosso tradicional sorteio do mês – abril.

Esse é o start para você se aventurar na automação da sua casa e parar de jogar o chinelo no interruptor na tentativa de desligar as luzes. Curioso em como fazer isso? Veja aqui então Como acender lâmpadas pela internet com este kit!

O nosso Kit Automação Residencial conta com os seguintes componentes:

01 – Placa Uno R3
01 – Cabo USB
01 – Fonte DC Chaveada 9V 1A Plug P4
01 – Ethernet Shield W5100
01 – Cabo de Rede Conector RJ45 1,5m
40 – Jumpers Macho-Fêmea
01 – Módulo Relé 5V 2 Canais
01 – Fio Simples 1,0mm 3m
02 – Lâmpadas E14 15W
02 – Soquetes Lâmpadas E14
01 – Plug Tomada Macho

COMO PARTICIPAR

Quer participar mas não sabe como? A gente te explica. É super fácil. Basta responder às perguntas no aplicativo abaixo e curtir nossa Fanpage no Facebook para não perder o resultado!

a Rafflecopter giveaway

RESULTADO SORTEIO KIT AUTOMAÇÃO RESIDENCIAL

Você tem até às 23:59h do dia 19 de abril de 2017 para participar. O resultado será divulgado no dia 20 de abril de 2017 às 10h, neste blogpost e no Facebook da FilipeFlop. Durante este período não deixe de acompanhar nossas redes sociais, alertaremos sobre o prazo, além de outras novidades que compartilhamos por lá.

O vencedor será comunicado do resultado através do email por ele cadastrado, no qual será solicitado o envio dos seus dados cadastrais: nome completo, CPF, email, endereço e telefone. Caso o vencedor não responda ao nosso contato em até 48 horas, um novo sorteio será realizado.

Boa sorte

Site: Blog FILIPEFLOP

Medindo corrente e tensão com o módulo INA219

Durante o desenvolvimento de algum dos seus projetos você já deve ter tido a necessidade de medir a tensão ou a corrente consumida pelo seu projeto ou parte dele. Normalmente utilizamos um multímetro e medimos uma grandeza por vez (algo não muito prático). Neste artigo veremos como montar um simples e prático medidor de tensão e corrente DC utilizando como componente principal o current monitor módulo INA219 da Texas Instruments.

Para apresentar as leituras utilizaremos um Display de LCD 16×2 com um adaptador i2c, o que irá minimizar bastante a quantidade de pinos necessários, se comparado a tradicional utilização com interface paralela, seja de 4 bits ou 8 bits.

PRINCIPAIS MATERIAIS UTILIZADOS

• Sensor de Corrente DC INA219 I2C
• Display LCD 16×2 Backlight Azul
• Módulo Serial I2C para Display LCD Arduino
• Placa Nano V3.0

O SENSOR DE CORRENTE DC MODULO INA219

O INA219 é um componente extremamente versátil para o monitoramento de grandezas elétricas DC. Permite o monitoramento de linhas com alimentação de 0 a 26 Vdc, corrente com limite máximo dependente do resistor shunt utilizado, conversor ADC interno de 12 bit e interface i2c para comunicação. O método de medição de corrente utilizado é o high-side, onde o resistor shunt é colocado entre a fonte de alimentação e a carga. Este método permite que o dispositivo meça tanto a corrente circulante, como a tensão na carga. O datasheet do componente pode ser encontrado neste LINK.

Medição em High-Side e Low-Side

Como mencionado anteriormente, a medição da corrente é realizada através de um resistor shunt, ou seja, nossa boa e velha Lei de Ohm. Lembre-se que quando uma corrente elétrica atravessa um resistor surge em seus terminais uma diferença de potencial, ou seja, surge uma tensão que é proporcional a corrente circulando através do resistor.

 U = R x I

Ao medirmos a tensão sobre um resistor qualquer, de posse da resistência do mesmo podemos substituir os valores na equação e com isso obter a corrente elétrica.

A placa Sensor de Corrente DC INA219 I2C facilita muito os projetos envolvendo este componente pois já engloba o circuito integrado, os componentes passivos necessários para seu funcionamento, um resistor shunt de 0.100R (100 miliOhm) que permite medição de correntes máximas de +- 3,2 A (tensão máxima de +-320 mV no resistor shunt) e também terminais para conexão com o microcontrolador e com a fonte que irá alimentar a carga a ser monitorada. A placa possui também dois conjuntos de pads/jumpers que permitem modificar o endereço i2c do dispositivo, ou seja, podemos utilizar até 4 dispositivos ao mesmo tempo em uma mesma linha i2c.

Placa INA219 DC Current Sensor

A alimentação do módulo INA219 é realizada através dos terminais Vcc e Gnd, podendo variar de 3 V a 5,5 Vdc, ou seja, dentro dos limites da maiorias das placas disponíveis atualmente, incluindo a placa Nano V3.0 utilizada neste projeto.

Os pinos Sda e Scl são referentes a comunicação i2c, e devem ser conectados respectivamente aos pinos A4 e A5 da placa Nano. Os pinos Vin+ e Vin- presentes tanto na barra de pinos, como no conector parafusável, são utilizados para monitorar a carga. A fonte que alimenta a carga (com tensões de 0 a 26 V) entra no terminal Vin+, atravessa o resistor shunt e sai pelo terminal Vin-, indo para a carga a ser monitorada. Aqui fica uma dica, para cargas que consumam pouca corrente você pode utilizar os terminais na barra de pinos inferior, na dúvida, utilize o terminal parafusável superior.

Uma consideração importante, o Gnd do nosso circuito de medição deverá estar conectado ao Gnd da nossa carga, por exemplo, se você estiver monitorando o consumo de um motor conectado a uma bateria de 9V, o terminal “-” da bateria deverá ser conectado ao Gnd geral. Isto garante que os circuitos operem sob mesmo referencial, ao mesmo tempo que assegura que a tensão será medida corretamente.

DISPLAY DE LCD 16X2 E ADAPTADOR I2C

Iremos utilizar um tradicional display LCD 16×2 para apresentar as medições. nativamente este display utiliza uma interface paralela, necessitando de pelo menos 6 pinos na versão 4 bits, conforme pode ser visto neste artigo do blog,  ou até 11 pinos na versão 8 bits.

Para minimizar a quantidade de pinos necessários iremos utilizar um Módulo Serial I2C para Display LCD. Este módulo permite comunicar com o LCD através da interface serial I2C, utilizando apenas 2 terminais (SDA e SCL). O módulo pode ser soldado diretamente ao display de LCD ou então pode-se cortar e soldar uma barra de pinos fêmea. permitindo que você altere a interface de acordo com suas necessidades.

CIRCUITO MODULO INA219 COM ARDUINO

Para montagem básica precisaremos de uma protoboard, uma fonte para alimentar nosso circuito e alguns jumpers. Indico utilizarem jumpers rígidos pois além da estética melhor, eles acabam evitando problemas de mau contato.

Iremos alimentar as linhas superior e inferior do protoboard com 5 V. Essa alimentação será útil para alimentar a placa Nano, o módulo INA219 e também nosso LCD via adaptador i2c.

Os pinos SDA e SCL, tanto da placa INA219 como do adaptador i2c deverão ser conectados respectivamente os pinos A4 e A5, que neste projetos serão utilizados para comunicação i2c.

O circuito a seguir apresenta as conexões básicas necessárias.

Veja que é um circuito bastante simples, restando apenas conectar a fonte que irá alimentar a carga ao conector Vin+, conectar Vin- a carga e lembrar de interconectar o Gnd dos circuitos.

BIBLIOTECAS NECESSÁRIAS

Para realização deste projeto será necessário adicionar duas novas bibliotecas, a Adafruit_INA219 e a LiquidCrystal_I2C. Aconselho utilizar o utilitário de gerenciamento de bibliotecas para facilitar o processo. Clique em Sketch >> incluir Biblioteca >> Gerenciar Bibliotecas…. No campo de busca insira o nome das bibliotecas Adafruit INA219 e LiquidCrystal I2C. Na lista que aparecer, selecione a biblioteca indicada e então clique em “Instalar”.

CÓDIGO FONTE

As bibliotecas utilizadas para o INA219 e para o LCD via i2c possuem exemplos de sua utilização que serviram como base para este projeto.

A seguir é apresentado o código que une as funcionalidade do nosso sensor de corrente e tensão e do nosso LCD via serial I2C.

/*
 * DC Current and Voltage Meter - Basic Code
 * - Use one INA219, an i2c current monitor from TI
 * with 12 bit ADC, capable to monitor Voltage and
 * Current
 * 
 * -------------------------------------------------
 * Medidor corrente e tensão DC - Código Básico
 * - Utiliza um modulo INA219, um monitor de corrente i2c
 * com um ADC de 12 bit, capaz de monitorar Tensão
 * e Corrente
 * 
 * developed by: Haroldo Amaral
 * 2017/03/26 - v 1.0
 */

#include <Wire.h> 
#include <LiquidCrystal_I2C.h>      // lcd i2c lib
#include <Adafruit_INA219.h>        // ina219 lib

// Define some constants used in code
const int LED1 =  2;        // the number of the LED pin
const int LED2 =  3;        // the number of the LED pin
const int ON = 1;           // on state
const int OFF = 0;          // off state
const int LCD_addr = 0x3F;  // LCD i2c address
const int LCD_chars = 16;   // number of characters
const int LCD_lines = 2;    // number of lines
const int INA_addr = 0x40;  // INA219 address


// set the LCD address to 0x3F for a 16 chars and 2 line display
// indica o endereço do LCD  - 0x3F, com 16 caracteres e 2 linhas
LiquidCrystal_I2C lcd(LCD_addr, LCD_chars, LCD_lines);

// set the INA219 to address 0x40
// indica o endereço do INA219 - 0x40
Adafruit_INA219 ina219(INA_addr);

// global variables
float shuntvoltage = 0;
float busvoltage = 0;
float current_mA = 0;
float loadvoltage = 0;

// Prototype of functions
void Read_INA219_Values(void);
void LCD_Update(void);
void Serial_Send(void);

void setup()
{
  // configure LED pins
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);

  // configure the serial to 9600bps
  Serial.begin(9600);

  Serial.println("Hello!");
  Serial.println("Measuring voltage and current with INA219 ...");
  
  // initialize the INA219
  ina219.begin();

  // initialize the lcd 
  lcd.init();
  lcd.clear();

  // Print a message to the LCD.
  lcd.backlight();

  // set the cursor and write some text
  lcd.setCursor(0,0);
  lcd.print("Tensao Corrente"); 
}

/*
 * MAIN LOOP
 * - change the led state, measure the values and update LCD
 */
void loop()
{
  // read values from INA219
  // lê os valores do INA219
  Read_INA219_Values();

  // update the LCD
  // atualiza o LCD
  LCD_Update();

  // send data over the serial
  // envia os dados pela serial
  Serial_Send();

  // change the value to increase/decrease the update rate
  // mude o valor para alterar a taxa de atualização
  delay(250);
}

/*
 * Functions
 */

// Read the values from INA219
// lê os valores convertidos pelo modulo INA219
void Read_INA219_Values(void)
{
  shuntvoltage = ina219.getShuntVoltage_mV();
  busvoltage = ina219.getBusVoltage_V();
  current_mA = ina219.getCurrent_mA();
  loadvoltage = busvoltage + (shuntvoltage / 1000);
}

// update the LCD with values
// atualiza o LCD com os valores
void LCD_Update(void)
{
  lcd.setCursor(0,1);
  lcd.print(busvoltage);  lcd.print("V   ");

  lcd.setCursor(7,1);
  lcd.print(current_mA); lcd.print("mA   ");
}

// Send data over the serial
// envia os valores pela serial
void Serial_Send(void)
{
  Serial.print("Bus Voltage:   "); Serial.print(busvoltage); Serial.println(" V");
  Serial.print("Shunt Voltage: "); Serial.print(shuntvoltage); Serial.println(" mV");
  Serial.print("Load Voltage:  "); Serial.print(loadvoltage); Serial.println(" V");
  Serial.print("Current:       "); Serial.print(current_mA); Serial.println(" mA");
  Serial.println("");
}

Com o exemplo rodando serão apresentadas no LCD a tensão e corrente da carga. Neste exemplo utilizei 1 LED vermelho como carga teste.

UM SEGUNDO TESTE COM O MODULO INA219

Para fixarmos os conceitos irei demonstrar um exemplo medindo a tensão e a corrente consumida por todo o circuito de medição e mais dois LED’s controlados pela própria sketch.

Como queremos medir o consumo da placa Nano, do Display LCD e de mais dois LED’s, serão necessárias alguma modificações pontuais no circuito. A principal delas é que a alimentação de 5V fornecida pela fonte ajustável, será conectada apenas as linhas de alimentação superiores, na parte interior iremos deixar o jumper da fonte na posição “off”. A alimentação de 5V será aplicada ao pino Vin+ e o pino Vin- será conectado a linha de alimentação inferior, permitindo alimentar a placa Nano e também o Display de LCD.

O circuito de teste é apresentado a seguir.

CÓDIGO FONTE

Neste teste o código irá controlar o backlight e os dois leds para demonstrar a medição de tensão e corrente. Inicialmente é mostrada a medição com backlight aceso e com os leds apagados, após um delay o backlight é apagado, o backlight é novamente aceso e um dos LEDs também, o segundo LED é aceso. Entre cada etapa ocorre a leitura dos valores medidos pelo INA219, atualização do display e geração de um delay de 2 segundos.

O código é apresentado a seguir.

/*
 * DC Current and Voltage Meter - LED test
 * - Use one INA219, an i2c current monitor from TI
 * with 12 bit ADC, capable to monitor Voltage and
 * Current
 * - In the test, the LEDs and the backlight are 
 * switched to verify the current consumption
 * 
 * -------------------------------------------------
 * Medidor corrente e tensão DC - LED test
 * - Utiliza um modulo INA219, um monitor de corrente i2c
 * com um ADC de 12 bit, capaz de monitorar Tensão
 * e Corrente
 * - No teste, os led e o backlight são chaveados
 * para verificar a corrente consumida
 * 
 * developed by: Haroldo Amaral
 * 2017/03/26 - v 1.0
 */

#include <Wire.h> 
#include <LiquidCrystal_I2C.h>      // lcd i2c lib
#include <Adafruit_INA219.h>        // ina219 lib

// Define some constants used in code
const int LED1 =  2;        // the number of the LED pin
const int LED2 =  3;        // the number of the LED pin
const int ON = 1;           // on state
const int OFF = 0;          // off state
const int LCD_addr = 0x3F;  // LCD i2c address
const int LCD_chars = 16;   // number of characters
const int LCD_lines = 2;    // number of lines
const int INA_addr = 0x40;  // INA219 address


// set the LCD address to 0x3F for a 16 chars and 2 line display
// indica o endereço do LCD  - 0x3F, com 16 caracteres e 2 linhas
LiquidCrystal_I2C lcd(LCD_addr, LCD_chars, LCD_lines);

// set the INA219 to address 0x40
// indica o endereço do modulo INA219 - 0x40
Adafruit_INA219 ina219(INA_addr);

// global variables
float shuntvoltage = 0;
float busvoltage = 0;
float current_mA = 0;
float loadvoltage = 0;

// Prototype of functions
void Read_INA219_Values(void);
void LCD_Update(void);
void Serial_Send(void);

void setup()
{
  // configure LED pins
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);

  // configure the serial to 9600bps
  Serial.begin(9600);

  Serial.println("Hello!");
  Serial.println("Measuring voltage and current with INA219 ...");
  
  // initialize the INA219
  ina219.begin();

  // initialize the lcd 
  lcd.init();
  lcd.clear();

  // Print a message to the LCD.
  lcd.backlight();

  // set the cursor and write some text
  lcd.setCursor(0,0);
  lcd.print("Tensao Corrente"); 
}

/*
 * MAIN LOOP
 * - change the led state, measure the values and update LCD
 */
void loop()
{
  // test 1 - backlight on, leds off
  // teste 1 - backlight aceso, leds apagados
  digitalWrite(LED1, OFF);
  digitalWrite(LED2, OFF);
  Read_INA219_Values();
  LCD_Update();
  Serial_Send();
  delay(2000);

  // test 2 - backlight off, leds off
  // teste 2 - backlight apagado, leds apagados
  lcd.noBacklight();
  Read_INA219_Values();
  LCD_Update();
  Serial_Send();
  delay(2000);

  // test 3 - backlight on, led 1 ON
  // teste 3 - backlight aceso, led 1 aceso
  lcd.backlight();
  digitalWrite(LED1, ON);
  Read_INA219_Values();
  LCD_Update();
  Serial_Send();
  delay(2000);

  // test 4 - backlight on, led 1 and 2 ON
  // teste 4 - backlight aceso, led 1 e 2 aceso
  digitalWrite(LED2, ON);
  Read_INA219_Values();
  LCD_Update();
  Serial_Send();
  delay(2000);
}

/*
 * Functions
 */

// Read the values from INA219
// lê os valores convertidos pelo modulo INA219
void Read_INA219_Values(void)
{
  shuntvoltage = ina219.getShuntVoltage_mV();
  busvoltage = ina219.getBusVoltage_V();
  current_mA = ina219.getCurrent_mA();
  loadvoltage = busvoltage + (shuntvoltage / 1000);
}

// update the LCD with values
// atualiza o LCD com os valores
void LCD_Update(void)
{
  lcd.setCursor(0,1);
  lcd.print(busvoltage);  lcd.print("V   ");

  lcd.setCursor(7,1);
  lcd.print(current_mA); lcd.print("mA   ");
}

// Send data over the serial
// envia os valores pela serial
void Serial_Send(void)
{
  Serial.print("Bus Voltage:   "); Serial.print(busvoltage); Serial.println(" V");
  Serial.print("Shunt Voltage: "); Serial.print(shuntvoltage); Serial.println(" mV");
  Serial.print("Load Voltage:  "); Serial.print(loadvoltage); Serial.println(" V");
  Serial.print("Current:       "); Serial.print(current_mA); Serial.println(" mA");
  Serial.println("");
}

O resultado deste teste você confere na imagem do início do post, e os arquivos deste projeto (sketches e esquemático do Fritzing) podem ser baixados no meu repositório GitHub.

Gostou do Medidor de tensão e corrente DC com módulo INA219? Ajude-nos a melhorar o blog atribuindo uma nota a este tutorial (estrelas no final do artigo), comente e visite nossa loja FILIPEFLOP!

Site: Blog FILIPEFLOP

Receptor de rádio online com Raspberry Pi

Rádios online não são novidade, é verdade. Porém, constituem um meio ainda fantástico de se ouvir música e notícias do mundo todo e, por que não, conhecer novas culturas também. Quando idealizadas e popularizadas, o único dispositivo que tornava possível ouvir uma rádio online era um computador. Mas os tempos mudaram e hoje é possível fazer isso até mesmo de seu smartphone. Neste artigo, será mostrado como construir seu próprio receptor de rádio online com Raspberry Pi rodando a distribuição Linux Raspbian.

O que é necessário comprar para reproduzir o projeto?

Para fazer o projeto de rádio online com Raspberry Pi, será necessário:

• Placa Raspberry Pi
• Fonte de alimentação 5V/3A
• Cabo HDMI (para ligar a Raspberry Pi a um monitor ou TV e programá-la)
• Mouse e teclado (com ou sem fio)
• Um display OLED (da cor que preferir)
• Cinco botões pulsantes / push-button (modelos e cores à sua escolha)
• Jumpers macho-fêmea
• Uma protoboard (uma do tamanho de 400 pontos é suficiente)

No caso, a Raspberry Pi é o “cérebro” do projeto. Uma vez que o projeto estiver rodando, a rádio-online que estiver tocando no momento irá aparecer do display OLED e será possível controlar totalmente o projeto através dos 5 botões pulsantes / push-buttons. Os botões terão as seguintes funções:

• Play/pause
• Aumentar volume
• Diminuir volume
• Ir para a próxima estação
• Voltar à estação anterior

Neste projeto de rádio online com Raspberry Pi, podem ser utilizado qualquer modelo de placa (desde que contenham conexão com a Internet), incluindo a Raspberry Pi 3 Model B e a Raspberry Pi A+ à venda em nossa loja FILIPEFLOP.

Como funciona a rádio online com Raspberry Pi?

O princípio de funcionamento deste projeto está na comunicação entre processos no Linux. Cada aplicação executada no Linux pode ser um processo (funcionamento temporário) ou serviço (funcionamento permanente), ficando a cargo do Kernel Linux gerenciar a execução dos mesmos.

O projeto deste post será um processo, o qual se comunicará com um player de mídia do Linux para tocar as rádios online, sendo este player um outro processo em execução. O player de mídia em questão é o mplayer, um player muito leve e consagrado do Linux (já testado a exaustão, com sucesso, ao longo dos anos em várias distribuições). Este player pode tocar diferentes tipos de mídia, sendo uma solução leve e elegante para quem deseja tocar mídias no Linux.

Portanto, em termos de funcionamento, o projeto aqui desenvolvido irá se comunicar com o mplayer, enviando comandos ao mesmo através de uma técnica chamada de named pipes.  Esta técnica permite que processos distintos no Linux se comuniquem / enviem mensagens uns aos outros, ficando a cargo do Kernel Linux gerenciar a transferências destas mensagens. No caso específico deste projeto, as mensagens trafegadas entre o receptor e o mplayer são os comandos que o mplayer aceita em modo slave, e são escritas e lidas em arquivos FIFO (arquivos especiais para esta finalidade) salvos no diretório /tmp. Não se preocupe com a quantidade de I/Os nesses arquivos, pois no Linux todos os arquivos FIFO são criados/mapeados em RAM!

Preparação: instalação do mplayer e escolha das rádios online

Antes de prosseguir com o projeto, é necessário instalar o mplayer. Para isto, utilize o comando abaixo:

sudo apt-get install mplayer2

A instalação é rápida e não ocupará muito espaço na memória.

Para a escolha das rádios online, uma das formas é carregar nele arquivos do tipo playlist (.pls) da rádio on-line desejada. Portanto, ao escolher suas rádios a serem ouvidas, procure pela playlist / endereço da playlist em formato .pls. Abaixo há alguns exemplos, todos tirados do site SHOUTCast:

• http://yp.shoutcast.com/sbin/tunein-station.pls?id=1057392
• http://panel3.serverhostingcenter.com:2199/tunein/radiobackstage1.pls
• http://yp.shoutcast.com/sbin/tunein-station.pls?id=142571

Ainda, você pode testar o funcionamento do mplayer ao tocar uma rádio de sua escolha com o seguinte comando:

mplayer -playlist URL_DO_ARQUIVO_PLS_DA_RADIO_ONLINE_DESEJADA

Circuito Esquemático

O circuito esquemático do projeto pode ser visto abaixo:

Código-fonte projeto Rádio online com Raspberry Pi

Veja abaixo o código-fonte do projeto!
Observação: para maiores informações das bibliotecas a serem instaladas para o funcionamento do display OLED na Raspberry Pi, veja este nosso artigo.

#Projeto: Radio on-line com Raspberry Pi
import os
import sys
import subprocess
import shlex
import Adafruit SSD1306

from PIL import Image
from PIL import ImageDraw
from PIL import ImageFont

#Variaveis globais
CaminhoArquivoControle="/tmp/ControleRadio"
ComandoMPlayer = "mplayer -input file=/tmp/ControleRadio -slave -playlist "

#variaveis relacionadas ao display OLED
RST = 24
disp = Adafruit_SSD1306.SSD1306_128_64(rst=RST)  #Display OLED 128x64 (I2C)
top = 0


#Variaveis das playlists
Playlists=[]        #Array que contem todas as playlists
NumeroPlaylists = 0 #quantidade de playlists
NomesRadios=[]      #Nomes das radios / playlists
PlaylistEscolhida=0 #Indice da playlist escolhida

#Variaveis relacionadas aos botoes de comando
PinoPlayPause = 18     # Broadcom pin 18 (no conector P1, pino 12)
PinoSobeVolume = 17    # Broadcom pin 17 (no conector P1, pino 11)
PinoDesceVolume = 22   # Broadcom pin 22 (no conector P1, pino 15)
PinoRadioAnterior = 27 # Broadcom pin 27 (no conector P1, pino 13)          
PinoProximaRadio = 23  # Broadcom pin 23 (no conector P1, pino 16)                   


NomeRadio1="Radio ShoutCast"
NomeRadio2="Radio Backstage (www.radiobackstage.com)"

#Funcao: inicia lista de playlists
#Parametros: nenhum
#Retorno: nenhum
def IniciaListaPlaylists():
	global Playlists
	global NomesRadios
	global NumeroPlaylists

	#playlist 1
	Playlists.append("http://yp.shoutcast.com/sbin/tunein-station.pls?id=1057392")
	NomesRadios.append("Radio Shoutcast")

	#playlist 2
	Playlists.append("http://panel3.serverhostingcenter.com:2199/tunein/radiobackstage1.pls")
	NomesRadios.append("Radio Backstage")

	#playlist 3
	Playlists.append("http://yp.shoutcast.com/sbin/tunein-station.pls?id=1425714")
	NomesRadios.append("Techno")

	NumeroPlaylists=3
	return

#Funcao: Toca a plsylist escolhida
#Parametros: nenhum
#Retorno: nenhum
def TocaPlaylist(PEscolhida):
	global Playlists
	global ComandoMPlayer

	os.system("pkill -f mplayer")
	ComandoPlaylist = ComandoMPlayer + Playlists[PEscolhida]
	
	#inicia processo e direciona o stdout para /dev/null
	FNULL = open(os.devnull,'w')
	args = shlex.split(ComandoPlaylist)
	InterfaceMPlayer = subprocess.Popen(args, shell=False, stdin=subprocess.PIPE, stdout=FNULL, stderr=subprocess.STDOUT)

	#ajusta volume em 50%
	os.system('echo "volume 50" >'+CaminhoArquivoControle)

	return


#Funcao: cria arquivo de controle do player (MPlayer)
#Parametros: nenhum
#Retorno: nenhum
def CriaArquivoControle():
	#se arquivo ja existe, nada e feito.
	if (os.path.exists(CaminhoArquivoControle)):
		return

	try:
		os.mkfifo(CaminhoArquivoControle)
	except:
		print "Falha ao criar arquivo de controle. Por favor, verifique o caminho de criacao do mesmo."
		exit(1)
	
	
#Funcao: escreve radio atual e estado da reproducao no display
#Parametros: nome da radio, estado de reproducao, tamanho da tela (altura e largura)
#            e objetos (draw, image e disp)
#Retorno: nenhum
def EscreveDisplay(NomeDaRadio, EstadoReproducao, AlturaDisplay, LarguraDisplay, draw, image, disp):
        global top
    
    #Apaga display desenhando um retangulo preto que ocupa toda a tela
	draw.rectangle((0,0,LarguraDisplay,AlturaDisplay), outline=0, fill=0)
	     
    font = ImageFont.load_default()
	draw.text((x, top), 'Player - radio online', font=font, fill=255)
	draw.text((x, top+20), 'Tocando:', font=font, fill=255)
	draw.text((x, top+40), NomeDaRadio, font=font, fill=255)
	draw.text((x, top+60), 'Status: ', font=font, fill=255)
	draw.text((x, top+80), EstadoReproducao, font=font, fill=255)
	disp.image(image)
	disp.display()	
	return	
	
#------------------
#Programa principal
#------------------

#inicializacoes dos GPIOs
GPIO.setmode(GPIO.BCM)
GPIO.setup(PinoPlayPause, GPIO.IN, pull_up_down=GPIO.PUD_UP)      #input c/ pull-up
GPIO.setup(PinoSobeVolume, GPIO.IN, pull_up_down=GPIO.PUD_UP)     #input c/ pull-up
GPIO.setup(PinoDesceVolume, GPIO.IN, pull_up_down=GPIO.PUD_UP)    #input c/ pull-up
GPIO.setup(PinoRadioAnterior, GPIO.IN, pull_up_down=GPIO.PUD_UP)  #input c/ pull-up
GPIO.setup(PinoProximaRadio, GPIO.IN, pull_up_down=GPIO.PUD_UP)   #input c/ pull-up

#inicializacoes do display
disp.begin()
disp.clear()
disp.display()
width = disp.width
height = disp.height
image = Image.new('1', (width, height)) 
draw = ImageDraw.Draw(image)
padding = 2
shape_width = 20
top = padding
bottom = height-padding
x = padding

#Inicializa lista de playlists
IniciaListaPlaylists()

#Cria arquivo de controle e inicia processo MPlayer
CriaArquivoControle()

#Toca playlist 1
TocaPlaylist(PlaylistEscolhida)

#escreve no display a radio que esta tocando
EscreveDisplay(NomesRadios[PlaylistEscolhida], 'Tocando', height,width, draw,image, disp)

while True:
	try:
		
		if (!GPIO.input(PinoPlayPause)):
			print "[ACAO] Play/Pause"
			os.system('echo "pause" > '+CaminhoArquivoControle)

		if (!GPIO.input(PinoSobeVolume)):
			print "[ACAO] Sobe volume"
			os.system('echo "volume +10" > '+CaminhoArquivoControle)

		if (!GPIO.input(PinoDesceVolume)):
			print "[ACAO] Desce volume"
			os.system('echo "volume -10" > '+CaminhoArquivoControle)

		if (!GPIO.input(PinoProximaRadio)):
			print "[ACAO] Proxima estacao"
			PlaylistEscolhida = PlaylistEscolhida + 1
			if (PlaylistEscolhida == NumeroPlaylists):
				PlaylistEscolhida = 0
			TocaPlaylist(PlaylistEscolhida)
			EscreveDisplay(NomesRadios[PlaylistEscolhida], 'Tocando', height,width, draw,image, disp)

		if (!GPIO.input(PinoRadioAnterior)):
			print "[ACAO] Estacao anterior"
			PlaylistEscolhida = PlaylistEscolhida - 1
			if (PlaylistEscolhida < 0):
				PlaylistEscolhida = NumeroPlaylists-1
			TocaPlaylist(PlaylistEscolhida)
			EscreveDisplay(NomesRadios[PlaylistEscolhida], 'Tocando', height,width, draw,image, disp)


	except (KeyboardInterrupt):
		print "Aplicacao sendo encerrada."
		exit(1)

Copie e cole este código em um editor de texto de sua preferência (sugestão: nano) e salve o arquivo como ReceptorRadioOnlineRasp.py. Para executar o projeto, utilize o seguinte comando:

python ReceptorRadioOnlineRasp.py

Abaixo você confere um vídeo do projeto em ação:

Gostou do post rádio online com Raspberry Pi? Ajude-nos a melhorar o blog atribuindo uma nota a este tutorial (estrelas no final do artigo), comente e visite nossa loja FILIPEFLOP!

Site: Blog FILIPEFLOP

Pilaroid: Câmera Instantânea com Raspberry Pi

Você já deve ter ouvido falar da câmera instantânea Polaroid que teve seu auge no século 20. São câmeras que tiram uma foto e imprimem instantaneamente utilizando um tipo de revelação química.

Como toda moda fica esquecida por um tempo mas volta com tudo, a Polaroid hoje tem diversos modelos de câmeras instantâneas, com impressão colorida, tecnologia touch e muito mais.

Mas como nós da FILIPEFLOP temos o espírito maker e gostamos de projetos DIY, decidimos fazer a nossa versão de câmera instantânea utilizando uma Raspberry Pi e uma mini impressora térmica e a batizamos de Pilaroid. E o que é melhor, disponibilizamos todas as instruções neste post para você também desenvolver sua câmera instantânea.

Material Utilizado

• Raspberry Pi 3
• Fonte DC 5V 3A para Raspberry Pi 3
• Impressora Térmica Embarcada
• Fonte 5V 2A para Impressora Térmica
• Câmera Raspberry Pi v2 8MP
• Botão Arcade Fliperama 60mm
• Led alto brilho

O sistema Linux utilizado na Raspberry foi o Raspbian Jessie Lite. As instruções de instalação do sistema podem ser encontradas no site da Raspberry Pi ou siga os primeiros passos com Raspberry Pi.

A impressora térmica embarcada nos possibilita a impressão em rolo comum de papel térmico de 57mm de largura, facilmente encontrado em papelarias. É possível imprimir dados de log, textos, gráficos, fotos, código de barras e etc. Sua comunicação via Serial/TTL facilita a integração dessa impressora com diversas plataformas como Arduino ou Raspberry Pi.

Veja também como utilizar a impressora térmica com Arduino.

A câmera utilizada é da própria Raspberry Pi e pode ser facilmente conectada na entrada CSI usando um cabo flat. É uma câmera de 8MP que faz fotos e vídeos utilizando a aplicação raspistill já instalada no Raspbian. Veja o funcionamento da câmera em detalhes aqui.

Configuração do Sistema

Antes de montar e conectar os componentes na Raspberry Pi vamos fazer a configuração do sistema.

Para que a impressora funcione corretamente na UART é necessário desabilitar o Bluetooth da Raspberry Pi 3 que também utiliza a mesma porta. Para isso, adicione no final do arquivo:

/boot/config.txt

A seguinte linha:

dtoverlay=pi3-disable-bt

Use um editor de texto de sua preferência como vi ou nano.

Então, desabilite o serviço de bluetooth, para que não haja interferência na porta UART:

sudo systemctl disable hciuart

Usando a aplicação raspi-config, habilite a câmera e desabilite o terminal serial

sudo raspi-config

Vá em Interfacing Options -> Camera -> Yes para habilitar a câmera.

Para desabilitar o terminal serial vá em Interfacing Options -> Serial -> No -> Yes -> Ok

Instalação dos Programas Necessários

Primeiramente vamos instalar o CUPS (Common UNIX Printing System) e alguns pacotes de dependência.

sudo apt update
sudo apt install git cups wiringpi build-essential libcups2-dev libcupsimage2-dev

Então instale o raster-filters para CUPS, um programa que processa formatos bitmap para o formato nativo de impressora térmica.

git clone https://github.com/adafruit/zj-58
cd zj-58
make
sudo ./install

Para adicionar a impressora térmica ao programa CUPS e utilizá-la como impressora padrão execute os seguintes comandos:

sudo lpadmin -p ZJ-58 -E -v serial:/dev/ttyAMA0?baud=19200 -m zjiang/ZJ-58.ppd
sudo lpoptions -d ZJ-58

Código Shell Script da Câmera Instantânea

O repositório clonado do github nos passos anteriores já acompanha um script que é responsável por fazer a leitura do botão, tirar a foto e enviar para a impressora térmica. Você encontra esse script em ‘zj-58/extras/camera.sh’.

Para nosso projeto, foram feitas algumas mudanças e o resultado foi o seguinte:

#!/bin/bash 

SHUTTER=16
LED=5 

# Initialize GPIO states
gpio -g mode  $SHUTTER up
gpio -g mode  $LED           out

# Pisca o LED ao iniciar o sistema
for i in `seq 1 10`;
do
   gpio -g write $LED 1
   sleep 0.1
   gpio -g write $LED 0
   sleep 0.1
done   

while :
do
   # Verifica se o botão foi pressionado
   if [ $(gpio -g read $SHUTTER) -eq 0 ]; then
       sudo cancel -a ZJ-58
       sudo cupsenable ZJ-58
       gpio -g write $LED 1
       /usr/bin/raspistill -n -br 65 -t 200 -w 512 -h 384 -o - | /usr/bin/lp
       /usr/bin/lp /home/pi/zj-58/extras/cartao.jpg
       sleep 1
       # Espera o usuário liberar o botão antes de terminar
       while [ $(gpio -g read $SHUTTER) -eq 0 ]; do continue; done
       gpio -g write $LED 0
   fi
done

As linhas mais importantes do programa são:

/usr/bin/raspistill -n -br 65 -t 200 -w 512 -h 384 -o - | /usr/bin/lp
/usr/bin/lp /home/pi/zj-58/extras/cartao.jpg

A primeira linha tira a foto em um formato 512×384 e joga via pipe para o programa lp.

A segunda imprime logo em seguida um pequeno cartão que fizemos especialmente para o evento TDC Florianópolis 2017.

Para que o programa inicie automaticamente edite com um editor de texto(vi ou nano) o arquivo ‘/etc/rc.local’, adicionando antes da linha “exit 0” o script camera.sh

sh /home/pi/zj-58/extras/camera.sh

Faça o reboot do sistema para que as mudanças tenham efeito.

Montagem do Circuito

Já que a impressora se comunica via UART, precisamos conectá-la nos pinos 6, 8 e 10 da Raspberry Pi da seguinte maneira:

O LED de indicação pode ser conectado nos pinos 29 e 25 como na tabela a seguir:

Lembre-se de usar um resistor com o LED. Pode ser de um valor pequeno como 220 ohms.

O botão é ligado em uma GPIO e Ground como na tabela a seguir:

Veja a montagem do circuito completo na figura a seguir:

Teste Final da Câmera Instantânea

Ligue o circuito nas fontes de energia. Quando o sistema iniciar você verá o LED piscar. Aperte o botão e veja sua foto sendo impressa:

Abaixo temos o vídeo da câmera em ação:

As instruções técnicas deste post e programa shell script são baseadas no projeto original de Phillip Burgess, engenheiro de criação da Adafruit. O post original em inglês pode ser encontrado aqui.

Gostou ? Ajude-nos a melhorar o blog atribuindo uma nota a este tutorial (estrelas no final do artigo), comente e visite nossa loja FILIPEFLOP!

Site: Blog FILIPEFLOP

Programando a Linkit One com Arduino IDE

Muitos usuários e demais leitores do FILIPEFLOP ficaram encantados com a Linkit One. Em tão pouco espaço, ela agrega tantas funcionalidades quanto um pequeno celular. E na apresentação dela destaquei que a mesma pode ser programada pela interface do Arduino. Isso é bem verdade, e será mostrado nesse artigo sobre a Linkit One com Arduino IDE.

Ao contrário de algumas outras placas compatíveis com o ecossistema de desenvolvimento Arduino, para programar a Linkit One é preciso instalar os drivers da placa, atualizar o Arduino IDE, atualizar seu bootloader, para então, por fim, poder programá-la com tudo que a ferramenta pode oferecer.

E uma observação importante: esse guia toma por base o uso de um computador com sistema operacional Windows! É possível usar a placa no Linux? Com certeza, mas trata-se de processos que serão mostrados em uma outra ocasião. Vamos então mostrar como configurar todo o ambiente para que você possa usar a Linkit One com Arduino IDE!

Instalando os Drivers da Linkit One

Então, em se tratando do Windows, é importante ter instalado no computador os drivers da placa. Para isso, primeiro certifique-se de ter acesso como administrador à máquina com Windows, e faça o download do arquivo de instalação neste link da MediaTek. Esse arquivo possui uma pasta compactada, chamada “windows-com-port-driver“. Descompacte essa pasta em algum lugar de sua preferência, e execute o arquivo contido dentro dessa pasta, que é o InstallMTKUSBCOMPortDriver.exe.

A instalação não tem segredo. É o tradicional “próximo-próximo-próximo-instalar”, etc.

Terminada a instalação, e antes de plugar a placa, realize as etapas a seguir como uma “precaução”:

• Abra o Painel de Controle, procure e abra a opção Mudar configurações de instalação de dispositivo.
• Em Configurações de Instalação de Dispositivo, selecione Não, deixe-me escolher o que fazer. E clique Nunca instalar drivers de software do Windows Update, como mostrado abaixo:

Para Windows 7:

No Windows 8 e 10:

Também, certifique-se de desmarcar Automaticamente obter aplicações e informações do dispositivo providas pelo fabricante.

Antes de finalmente plugar a Linkit One ao computador pelo cabo USB, certifique-se te que ela esteja no SPI Mode, modo controlado pela chave seletora mais ao meio da placa, conforme indicado na imagem adiante. Isso é importante porque esse modo encaminha como será feito o acesso à memória da placa. Para atualizar o Firmware/Bootloader, é preciso que esteja no SPI Mode.

 Chave seletora no modo SPI, agora é a hora de plugar a placa no computador pelo cabo USB.

Inicialmente, os dispositivos vinculados à LinkitOne não serão reconhecidos pelo Windows. Veja abaixo, na janela do Gerenciador de Dispositivos, do Painel de Controle do Windows.

Todavia, o Windows irá reconhecer os drivers, e irá lhe perguntar sobre a instalação desses drivers. Confirme que SIM, deseja instalar os drivers de dispositivos relacionados.

Passado algum tempo (segundos a minutos, depende do Windows e da sua máquina!), os dispositivos serão então apropriadamente reconhecidos, tendo portas de comunicação Seriais (COM) atribuídas a eles. Veja como ficarão, de acordo com o Gerenciador de Dispositivos.

Viram que há 2 portas seriais de comunicação? Dando uma prévia, a importante a ser utilizada no Arduino IDE será sempre a MTK USB Modem Port.

Configurando o Arduino IDE

Agora é a hora de colocarmos todo o setup de configuração da Linkit One com Arduino IDE. Uma boa notícia é que desde as versões 1.6.4 em diante, aproximadamente, o Arduino IDE é capaz de baixar e configurar automaticamente o setup de todo um perfil de placas, com base em um arquivo json informado no menu Preferences.

Sendo assim, para informar o arquivo de setup da Linkit One, abra a janela do Arduino IDE, e vá na opção de menu File, e depois em Preferences.

No campo “Additional Boards Manager URLs“, coloque o link http://download.labs.mediatek.com/package_mtk_linkit_index.json, como mostrado abaixo:

Veja que se você clicar no ícone ao lado do campo de texto, será aberto uma janela que irá permitir digitar um ou mais links de configuração json.

Inserido o link, clique no botão OK para salvar os links informados. O próximo passo agora é instalar todo o ecossistema de desenvolvimento da Linkit One adaptado ao Arduino IDE.

Para essa última etapa dessa parte do processo, vá ao menu Tools. Nesse menu, vá à opção Board, e depois em Boards Manager.

Quando clicar em Boards Manager, será aberta uma janela e o Arduino IDE irá atualizar as referências de placas cadastradas na IDE, dentre as quais estão as referências informadas pelo arquivo json inserido pouco tempo atrás. Como as placas/plataformas estão em ordem alfabética, procure o campo da Linkit One (irá estar mais abaixo). No campo da Linkit One, por padrão é selecionada a versão mais recente dos componentes da placa. Dessa forma, sem mais nem menos, clique no botão Install.

Terá início o processo de download e instalação dos componentes da Linkit One para o Arduino IDE. Terminado o processo, certifique-se de aparecer uma mensagem de “Installed“, no campo em que fica o nome da placa no Boards Manager (veja na mesma imagem acima, mais a direita no campo da Linkit Smart 7688 Duo, tem uma mensagem de INSTALLED).

Atualizando o Bootloader da Placa

Nessa etapa, será preciso mudar a forma como que a Linkit One se comporta com o computador. E antes disso, retire ela do cabo USB, e com ela desligada, deixe a Linkit One no modo Mass Storage, onde pela USB é possível acessar a memória Flash da placa diretamente. O modo Mass Storage é controlado pela primeira chave seletora, da esquerda pra direita, conforme indicado na figura abaixo.

O próximo passo é selecionar a placa Linkit One no menu Tools, e depois em Board. Veja abaixo como é a seleção.

Selecionada a “Board” Linkit One, todos os seus utilitários relacionados também serão selecionados pelo Arduino IDE, ou seja, a ferramenta se adapta para lidar com a placa.

Dentre os utilitários disponíveis, está o atualizador de Firmware, ou, em inglês, LinkIt Firmware Updater, que deve ser selecionado no Menu Tools, opção “Programmer“, item “LinkIt Firmware Updater“, como mostrado no caminho adiante.

Agora o Arduino IDE está preparado para gravar o bootloader na placa. Para essa etapa, clique no menu Tools, e por fim em Burn Bootloader.

Após clicar nessa opção, será aberta a janela do LinkIt Firmware Updater. Clique na seta verde, do ícone bem grande à direita da Janela.

O programa irá “vasculhar” as USBs presentes no computador, irá identificar a Linkit One presentemente conectada, e iniciará o processo de atualização do firmware da Linkit One. Veja abaixo como ficará a janela de progresso, em uma dada etapa do processo.

Finalizada a atualização do firmware, será exibida uma janela com a mensagem “Download complete”, indicando que tudo correu bem! (UFA!) Clique no botão OK para fechar, e mãos à obra para o próximo passo.

Programação Linkit One com Arduino IDE

Terminada a gravação do Bootloader, está tudo certo para a operação normal da placa Linkit One com Arduino IDE, de modo que agora seja possível carregar os programas compilados nela.

Para isso, é preciso virar aquela chave mais à esquerda da placa, próxima à porta USB, para o modo UART (ou também chamado de Modo Boot Normal). Veja na foto como a chave seletora deve ficar:

Conecte a Linkit One ao computador pelo cabo USB. Certifique-se pelo Gerenciador de Dispositivos de identificar qual a porta COM que é correspondente ao “MTK USB Modem Port“, que no meu caso ficou a porta COM4 (eu reconfigurei minhas portas). A porta indicada pelo MTK USB Modem Port é a porta a ser selecionada no Arduino IDE. No meu caso, marquei a porta COM4.

Seleção da porta COM correspondente ao MTK USB Modem Port (Vide Gerenciador de Dispositivos).

Pra esquentar a Linkit One com Arduino IDE, nada como o famoso pisca-Led com Serial, concordam? Copie e cole o código abaixo no novo sketch do Arduino.

//Programa: Linkit One com IDE Arduino

int LED_LINKIT = 13;
void setup() {
  //Define sinal do led como saida
  pinMode(LED_LINKIT, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  digitalWrite(LED_LINKIT, HIGH);   // Aciona o LED com nivel ALTO
  Serial.println("LED ACESO");
  delay(1000);                      // Delay de 1 segundo
  digitalWrite(LED_LINKIT, LOW);    // Desativa o LED com nivel BAIXO
  Serial.println("LED APAGADO");
  delay(1000);                      // Delay de 1 segundo
}

Clique no botão Compile & Run. Será iniciado o processo de compilação, e terminado, o código será carregado na placa.

Esses e demais tópicos podem ser vistos (em inglês) no Manual de Usuário da Linkit One.

Gostou deste post da Linkit One com Arduino IDE? Ajude-nos a melhorar o blog atribuindo uma nota a este tutorial (estrelas no final do artigo), comente e visite nossa loja FILIPEFLOP!

Site: Blog FILIPEFLOP

Monte um datalogger com BeagleBone Black

A BeagleBone Black é um nome muito importante no mundo maker, sobretudo no quesito de projetos IoT. Porém, nem sempre tudo está no “caminho feliz”. Imagine-se numa situação onde é preciso fazer um projeto para  registrar determinados dados (para posterior análise). Seria relativamente simples se utilizar uma plataforma como o ThingSpeak, por exemplo, certo? Mas e se o local onde o projeto for aplicado não possuir acesso à Internet (uma fazenda, por exemplo), como se faz? É isto que esse post irá mostrar, montando um datalogger com BeagleBone Black com a gravação dos dados em um pendrive.

O que é um datalogger?

Um datalogger é um dispositivo eletrônico capaz de registrar, ao longo do tempo, dados diversos (normalmente, originados de leituras de sensores). O estímulo (“trigger”) para o registro de um dado neste tipo de equipamento pode ser de dois tipos:

• Por periodicidade e amostragem: de tempos em tempos os dados são registrados, sendo assim uma aquisição à taxa de amostragem fixa (X amostras / segundo)
• Por evento: mediante o atendimento de alguma condição (nivel de sinal de um sensor, por exemplo), N dados são registrados. Aqui, como não há uma periodicidade, não se tem uma taxa de amostragem constante ao longo do registro de sinal.

Em suma, um datalogger é capaz de ler sensores e registrar os valores de leitura para posterior análise.

Onde os dados serão armazenados?

No projeto deste post, conforme já explicitado anteriormente, não se fará uso de Internet. Neste caso, como o volume de dados pode ser grande (você pode precisar registrar dados por períodos indo de poucos minutos até semanas dependendo da aplicação), iremos utilizar como memória de armazenamento dos registros um pendrive comum.

A BeagleBone Black conta com uma entrada USB Host, o que permite utilizar um pendrive na mesma sem nenhum adaptador adicional, como na imagem mostrada no início deste post.

Procedimento para uso do pendrive na BeagleBone Black

A título de conhecimento, o procedimento para utilização de um pendrive na BeagleBone Black pode ser visto a seguir:

• Acessar a BeagleBone Black via SSH. Se não sabe como fazer isto, confira este tutorial.
• Insira um pendrive na porta USB da placa
• No terminal (acesso via SSH), digite o seguinte comando:

  fdisk -l

  Este comando mostrará os discos / memórias de armazenamento presentes (no caso, a memória flash da placa e o pendrive). Observe a execução deste comando em uma BeagleBone Black nossa:

  Conforme observado na figura, o pendrive está se mostrando como um sistema de arquivos no dispositivo sda1 (/dev/sda1).

• Digite o seguinte comando:

  mkdir /media/usb

  Este comando irá criar o local onde o pendrive será montado no Linux.

• Faça a montagem do pendrive / memória de armazenamento. No Linux, a montagem é a inclusão de um sistema de arquivos qualquer (no caso, um pendrive) na árvore de sistema de arquivos do Linux. Em outras palavras, permitirá usar o pendrive como uma memória de armazenamento qualquer. Para fazer isto, digite o seguinte comando:

  mount /dev/sda1 /media/usb

  Onde /media/usb se refere ao diretório criado no passo 4.

• A partir deste momento, o pendrive pode ser acessado normalmente. Para acessá-lo e listar todos os arquivos gravados na pasta raíz, por exemplo, digite os seguintes comandos:

  cd /media/usb
  ls

Atenção: se desejar parar de usar o pendrive e/ou remover o pendrive da placa, SEMPRE faça a desmontagem, caso contrário corre-se um sério risco de danos à memória flash do pendrive. Isto é equivalente a quando usamos o “Remover dispositivo com segurança” no Windows. Para efetuar a desmontagem, utilize o seguinte comando:

umount /media/usb

Projeto Datalogger com BeagleBone Black

O projeto deste post é um datalogger de temperatura e umidade relativa do ar. Ambos os dados serão lidos a cada 10 segundos e registrados no pendrive na forma de um arquivo csv (o que permitirá, após a aquisição de dados, diretamente analisá-los em um programa como o Excel). O sensor utilizado é o DHT22.

O circuito esquemático do datalogger com BeagleBone Black pode ser visto a seguir. A alimentação pode ser feita tanto pela USB quanto pela entrada de fonte DC 5V.

Bibliotecas necessárias

Para este projeto, será necessário instalar a biblioteca (para Python) para comunicar com o sensor DHT22. O procedimento de instalação e link para o repositório GitHub da biblioteca é exibido neste site.

Código-fonte

O código-fonte do projeto pode ser visto a seguir.
IMPORTANTE: observe que o programa automaticamente monta e desmonta o pendrive. Portanto, para este projeto, não é preciso fazer a montagem e desmontagem manualmente.

#Projeto: Datalogger com BeagleBone Black - Temperatura e umidade. 
#         Salva os dados em um pendrive, na forma de um arquivo CSV.
#Autor: Pedro Bertoleti
#Data: Dezembro/2016

import os
import time
from datetime import datetime
import Adafruit_DHT

#Variaveis globais
ArqLog="/media/usb/Registros.csv"   #caminho do arquivo de log no pendrive
sensor = Adafruit_DHT.DHT22  #seleciona o tipo de sensor (no caso, DHT22)
pin='P8_11'  #pino da BeagleBone Black onde esta ligado o terminal de dados do DHT22


#Funcao: monta pendrive
#Parametros: nenhum
#Retorno: nenhum
def MontaPendrive():
        print("[PENDRIVE] Montando pendrive...")
	os.system("mount /dev/sda1 /media/usb")
        print("[OK] Pendrive montado")

#Funcao: desmonta pendrive
#Parametros: nenhum
#Retorno: nenhum
def DesmontaPendrive():
        print("[PENDRIVE] Desmontando pendrive...")
 	os.system("umount /media/usb")
        print("[OK] Pendrive desmontado")

#------------------
#Programa principal
#------------------

os.system("clear")

#monta pendrive
MontaPendrive()

#escreve cabecalho no arquivo
StrCabecalho="Data/Hora,Temperatura(.C),Umidade"
file = open(ArqLog,"w")
file.write(StrCabecalho)
file.write('\n')
file.close()

while(True):
	try:
	       #le a umidade e temperatura
               umidade, temperatura = Adafruit_DHT.read_retry(sensor, pin)
               
               #converte as leituras em string
               StrUmidade = str(umidade)
               StrTemperatura = str(temperatura)

               #compoe string contendo as duas informacoes
               StrDados = str(datetime.now())+","+StrTemperatura+","+StrUmidade

               #grava as informacoes no arquivo de log (em modalidade append)
               file = open(ArqLog,"a")
               file.write(StrDados)
               file.write('\n') 
               file.close()	

               #mostra na tela o dado registrado:
               print "[REGISTRO] Temperatura: "+StrTemperatura+"*C ; Umidade: "+StrUmidade
               print '\n'

               time.sleep(1)                
        except KeyboardInterrupt:
               file.close()
	       DesmontaPendrive()
	       print("Aplicacao encerrada.")
	       exit(1)

Salve o arquivo como DataLogger.py .

Resultado da execução do programa

Vamos agora testar o datalogger com BeagleBone Black. Primeiramente, insira o pendrive na BeagleBone Black. Em seguida, para executar o programa, digite o seguinte comando:

python DataLogger.py

A execução será iniciada. Primeiramente, será feita a montagem do pendrive. Em seguida, as leituras do sensor e gravações no arquivo csv. Finalmente, ao se pressionar Ctrl+C, o programa é encerrado. O resultado da execução na tela do terminal Linux é mostrado na figura abaixo:

Feito isso, remova o pendrive da BeagleBone Black e insira-o no computador. Você verá um arquivo CSV no pendrive chamado Registros.csv, conforme mostra a imagem a seguir:

A partir daqui, basta utilizar o arquivo CSV como quiser (inclusive no prórpio Excel)!

Se você desejar, pode utilizar algum visualizador de arquivos CSV online. Como sugestão, recomendo o Online CSV Viewer. Nele, configure o separador como vírgula (comma), conforme mostra a imagem a seguir:

Gostou do post Datalogger com BeagleBone Black? Ajude-nos a melhorar o blog atribuindo uma nota a este tutorial (estrelas no final do artigo), comente e visite nossa loja FILIPEFLOP

Site: Blog FILIPEFLOP

Concorra a um Kit Planta IoT com NodeMCU

A única coisa que você conseguiu cultivar foi cacto? Na sua casa não tem nenhuma planta? Já tentou de tudo mas todas acabam secando? Foi pensando em você que escolhemos o Kit Planta IoT com NodeMCU para o sorteio de maio. Com ele você vai ter uma planta smart que envia um tweet no exato momento em que você precisa fazer a regagem. O Kit Planta IoT com NodeMCU é a sua chance de impressionar com muitas flores e folhagens em casa. Não sabe como fazer? Fique tranquilo que ensinamos tudo em três tutoriais bem didáticos, basta acessar aqui: parte 1, parte 2 e parte 3.

O nosso Kit Plata IoT com NodeMCU conta com os seguintes componentes:

01 – Módulo WiFi ESP8266 NodeMCU ESP-12
01 – Sensor de Umidade do Solo Higrômetro
01 – Protoboard 400 Pontos
01 – Fonte DC Chaveada 5V 2A + Cabo Micro USB
65 – Jumpers Macho-Macho
20 – Resistores 100 Ohms
20 – Resistores 200 Ohms

COMO PARTICIPAR

Quer participar mas não sabe como? A gente te explica. É super fácil. Basta responder à pergunta no aplicativo abaixo e curtir nossa Fanpage no Facebook para não perder o resultado!

a Rafflecopter giveaway

RESULTADO SORTEIO KIT PLANTA IOT COM NODEMCU

Você tem até às 23:59h do dia 30 de maio de 2017 para participar. O resultado será divulgado no dia 31 de maio de 2017 às 11h, neste blogpost e no Facebook da FilipeFlop.

O vencedor será comunicado do resultado através do email por ele cadastrado, no qual será solicitado o envio dos seus dados cadastrais: nome completo, CPF, email, endereço e telefone. Caso o vencedor não responda ao nosso contato em até 48 horas, um novo sorteio será realizado.

Boa sorte

Site: Blog FILIPEFLOP

Usando Arduino GPS Shield com Google My Maps

O sistema GPS se mostra essencial nos dias de hoje. Ele está presente em drones, aviões comerciais, robôs terrestres e carros elétricos autônomos. Embora o sistema GPS esteja presente em diversas tecnologias de ponta, ele também está acessível a você que quer desenvolver seus projetos utilizando este recurso. Existem diversas maneiras de implementar um sistema de geolocalização usando GPS. Neste post iremos mostrar como gravar as coordenadas de GPS em um cartão SD e fazer a exibição desses dados no Google My Maps, usando o Arduino GPS Shield Duinopeak para Arduino.

Material Utilizado

• Arduino Uno R3
• Fonte DC Chaveada 9v 1A Plug P4
• GPS Shield para Arduino + Antena
• Cartão de Memória 8GB MicroSd SanDisk com Adaptador

Funcionamento do Shield GPS Duinopeak

O Arduino GPS Shield Duinopeak é composto das seguintes partes:

Ele se comunica com o Arduino através da interface UART com uma velocidade de transmissão padrão de 9600bps. É possível usar tanto a interface serial nativa do Arduino (Pinos D0 e D1) como uma interface serial via Software (Software Serial).

A interface serial de comunicação é selecionada entre os pinos D2 e D7 através de jumpers. Para este post deixaremos livre a porta Hardware Serial do Arduino para facilitar a programação do mesmo e usaremos os pinos 2 e 3 para comunicação via Software Serial com o shield GPS. Os jumpers devem ficar da seguinte maneira:

O Arduino GPS Shield conta também com um leitor de cartão SD que utiliza a interface SPI do Arduino para comunicação. Com isso existe a possibilidade de gravar os dados de GPS em um cartão SD funcionando como um datalogger. Mostraremos a utilização do cartão SD mais adiante. Lembrando que o cartão deve estar formatado em FAT.

O Shield possui dois LEDs de indicação. O LED PWR deve acender sólido indicando que o Shield está energizado e o LED TP deve piscar indicando que o Shield realizou a localização dos satélites de GPS.

Programa Arduino GPS Datalogger

Antes de compilar o programa exemplo, precisamos baixar e instalar a biblioteca TinyGPS. Com essa biblioteca é possível “parsear” os dados NMEA produzidos pelo GPS e extrair informações importantes como latitude, longitude, velocidade, número de satélites e etc.

Então esses dados são gravados em um arquivo no formato CSV dentro do cartão SD. Esse arquivo gerado terá nome GPSLOGxx.CSV e será incrementado um número cada vez que o Arduino reiniciar.

Para fazer o download da biblioteca TinyGPS acesse aqui e baixe o arquivo .zip da última versão da biblioteca. Então, na IDE do Arduino clique em Sketch -> Incluir Biblioteca -> Adicionar biblioteca .ZIP.

Copie o programa a seguir dentro da IDE Arduino e grave no Arduino.

/******************************************************************************
  This example uses SoftwareSerial to communicate with the GPS module on
  pins 8 and 9, then communicates over SPI to log that data to a uSD card.

  It uses the TinyGPS++ library to parse the NMEA strings sent by the GPS module,
  and prints interesting GPS information - comma separated - to a newly created
  file on the SD card.

  Resources:
  TinyGPS++ Library  - https://github.com/mikalhart/TinyGPSPlus/releases
  SD Library (Built-in)
  SoftwareSerial Library (Built-in)

  Development/hardware environment specifics:
  Arduino IDE 1.6.7
  GPS Logger Shield v2.0 - Make sure the UART switch is set to SW-UART
  Arduino Uno, RedBoard, Pro, Mega, etc.
******************************************************************************/

#include <SPI.h>
#include <SD.h>
#include <TinyGPS++.h>

#define ARDUINO_USD_CS 8 // uSD card CS pin (pin 8 on Duinopeak GPS Logger Shield)

/////////////////////////
// Log File Defintions //
/////////////////////////
// Keep in mind, the SD library has max file name lengths of 8.3 - 8 char prefix,
// and a 3 char suffix.
// Our log files are called "gpslogXX.csv, so "gpslog99.csv" is our max file.
#define LOG_FILE_PREFIX "gpslog" // Name of the log file.
#define MAX_LOG_FILES 100 // Number of log files that can be made
#define LOG_FILE_SUFFIX "csv" // Suffix of the log file
char logFileName[13]; // Char string to store the log file name
// Data to be logged:
#define LOG_COLUMN_COUNT 8
char * log_col_names[LOG_COLUMN_COUNT] = {
  "longitude", "latitude", "altitude", "speed", "course", "date", "time", "satellites"
}; // log_col_names is printed at the top of the file.

//////////////////////
// Log Rate Control //
//////////////////////
#define LOG_RATE 5000 // Log every 5 seconds
unsigned long lastLog = 0; // Global var to keep of last time we logged

/////////////////////////
// TinyGPS Definitions //
/////////////////////////
TinyGPSPlus tinyGPS; // tinyGPSPlus object to be used throughout
#define GPS_BAUD 9600 // GPS module's default baud rate

////////////////////////////////////////////////
// Arduino GPS Shield Serial Port Definitions //
////////////////////////////////////////////////
// If you're using an Arduino Uno, Mega, RedBoard, or any board that uses the
// 0/1 UART for programming/Serial monitor-ing, use SoftwareSerial:
#include <SoftwareSerial.h>
#define ARDUINO_GPS_RX 3 // GPS TX, Arduino RX pin
#define ARDUINO_GPS_TX 2 // GPS RX, Arduino TX pin
SoftwareSerial ssGPS(ARDUINO_GPS_TX, ARDUINO_GPS_RX); // Create a SoftwareSerial

// Set gpsPort to either ssGPS if using SoftwareSerial or Serial1 if using an
// Arduino with a dedicated hardware serial port
#define gpsPort ssGPS  // Alternatively, use Serial1 on the Leonardo

// Define the serial monitor port. On the Uno, Mega, and Leonardo this is 'Serial'
//  on other boards this may be 'SerialUSB'
#define SerialMonitor Serial

void setup()
{
  SerialMonitor.begin(9600);
  gpsPort.begin(GPS_BAUD);

  SerialMonitor.println("Setting up SD card.");
  // see if the card is present and can be initialized:
  if (!SD.begin(ARDUINO_USD_CS))
  {
    SerialMonitor.println("Error initializing SD card.");
  }
  updateFileName(); // Each time we start, create a new file, increment the number
  printHeader(); // Print a header at the top of the new file
}

void loop()
{
  if ((lastLog + LOG_RATE) <= millis())
  { // If it's been LOG_RATE milliseconds since the last log:
    if (tinyGPS.location.isUpdated()) // If the GPS data is vaild
    {
      if (logGPSData()) // Log the GPS data
      {
        SerialMonitor.println("GPS logged."); // Print a debug message
        lastLog = millis(); // Update the lastLog variable
      }
      else // If we failed to log GPS
      { // Print an error, don't update lastLog
        SerialMonitor.println("Failed to log new GPS data.");
      }
    }
    else // If GPS data isn't valid
    {
      // Print a debug message. Maybe we don't have enough satellites yet.
      SerialMonitor.print("No GPS data. Sats: ");
      SerialMonitor.println(tinyGPS.satellites.value());
    }
  }

  // If we're not logging, continue to "feed" the tinyGPS object:
  while (gpsPort.available())
    tinyGPS.encode(gpsPort.read());
}

byte logGPSData()
{
  File logFile = SD.open(logFileName, FILE_WRITE); // Open the log file

  if (logFile)
  { // Print longitude, latitude, altitude (in feet), speed (in mph), course
    // in (degrees), date, time, and number of satellites.
    logFile.print(tinyGPS.location.lng(), 6);
    logFile.print(',');
    logFile.print(tinyGPS.location.lat(), 6);
    logFile.print(',');
    logFile.print(tinyGPS.altitude.feet(), 1);
    logFile.print(',');
    logFile.print(tinyGPS.speed.mph(), 1);
    logFile.print(',');
    logFile.print(tinyGPS.course.deg(), 1);
    logFile.print(',');
    logFile.print(tinyGPS.date.value());
    logFile.print(',');
    logFile.print(tinyGPS.time.value());
    logFile.print(',');
    logFile.print(tinyGPS.satellites.value());
    logFile.println();
    logFile.close();

    return 1; // Return success
  }

  return 0; // If we failed to open the file, return fail
}

// printHeader() - prints our eight column names to the top of our log file
void printHeader()
{
  File logFile = SD.open(logFileName, FILE_WRITE); // Open the log file

  if (logFile) // If the log file opened, print our column names to the file
  {
    int i = 0;
    for (; i < LOG_COLUMN_COUNT; i++)
    {
      logFile.print(log_col_names[i]);
      if (i < LOG_COLUMN_COUNT - 1) // If it's anything but the last column
        logFile.print(','); // print a comma
      else // If it's the last column
        logFile.println(); // print a new line
    }
    logFile.close(); // close the file
  }
}

// updateFileName() - Looks through the log files already present on a card,
// and creates a new file with an incremented file index.
void updateFileName()
{
  int i = 0;
  for (; i < MAX_LOG_FILES; i++)
  {
    memset(logFileName, 0, strlen(logFileName)); // Clear logFileName string
    // Set logFileName to "gpslogXX.csv":
    sprintf(logFileName, "%s%d.%s", LOG_FILE_PREFIX, i, LOG_FILE_SUFFIX);
    if (!SD.exists(logFileName)) // If a file doesn't exist
    {
      break; // Break out of this loop. We found our index
    }
    else // Otherwise:
    {
      SerialMonitor.print(logFileName);
      SerialMonitor.println(" exists"); // Print a debug statement
    }
  }
  SerialMonitor.print("File name: ");
  SerialMonitor.println(logFileName); // Debug print the file name
}

Ao ligar o Arduino, dê uma caminhada na rua e logo você deverá ver o LED GPS fix piscar. Continue caminhando, ou ande de preferência de carro, para coletar uma boa quantidade de coordenadas.

Desligue o Arduino, retire o cartão e insira em algum computador. Você deverá ver o arquivo gerado. Abra o arquivo no excel e o arquivo deverá conter mais ou menos o seguinte conteúdo:

Visualizando as coordenadas no Google My Maps

Para melhor visualizar os dados coletados no arduino GPS Shield, você poderá carregá-los no Google My Maps.

Acesse o My Maps e clique em “Create a New Map”.

Para carregar o arquivo .CSV clique em “Import”.

Então busque e abra o arquivo .CSV gravado no cartão SD.

É possível fazer várias customizações no mapa, por exemplo, criar um traçado entre os pontos.

Veja neste link como criar e customizar mapas no My Maps.

Veja a seguir um mapa interativo com as coordenadas de GPS:

Gostou do Arduino GPS Shield Duinopeak? Ajude-nos a melhorar o blog atribuindo uma nota a este tutorial (estrelas no final do artigo), comente e visite nossa loja FILIPEFLOP!

Site: Blog FILIPEFLOP

Automação residencial com o Relé WiFi Sonoff

Muita gente já conhece o famoso ESP8266, um microcontrolador com WiFi capaz de se conectar a internet. Mas o que alguns não sabem é que ele já vem sendo utilizado em produtos como é o caso do Relé WiFi Sonoff, uma excelente opção para o seu projeto de automação residencial.

O Relé Wifi Sonoff, além de um chip ESP8266, possui internamente um regulador de tensão bivolt, ou seja, você pode ligar o Relé WiFi diretamente na rede elétrica de sua residência seja ela 110VAC ou 220VAC. O limite de corrente suportado pelo Relé é 10A.

Com esse relé você pode transformar sua casa em uma Smart Home, controlando equipamentos e eletrodomésticos por um aplicativo de celular.

A montagem e configuração do Relé Wifi Sonoff é bem simples e em poucos minutos você estará controlando sua casa pelo celular.

Montagem do Relé Wifi Sonoff

Remova as tampas de cobertura para ter acesso aos terminais.

Ligue os fios da rede elétrica, fase e neutro ao terminal de entrada Input. Em nosso caso utilizamos um conector de tomada. Ligue o dispositivo a ser acionado no terminal de saída Output. Nos nossos testes utilizamos uma lâmpada 220VAC.

Ao ligar o relé na rede elétrica um LED deve piscar a cada 2 segundos. Isso indica que o relé está funcionando.

Conectando o relé com o aplicativo de celular

Para conectar o relé ao aplicativo, pressione o botão do relé por 5 segundos. Assim ele entra em modo de emparelhamento.

Após apertar o botão por 5 segundos o LED piscará bem rápido indicando que está em modo emparelhamento, pronto para conectar ao aplicativo.

Baixe o aplicativo eWeLink. Ele pode ser encontrado tanto na AppStore para iOS como na Google PlayStore para Android.

Na tela inicial do aplicativo você verá opções de login. Clique no botão “Register” para criar uma nova conta ou faça login com o Facebook.

Na tela principal do aplicativo clique no botão “+” para adicionar um novo dispositivo.

Então você verá instruções para conexão do relé.

Clique em Next se o dispositivo já estiver em modo emparelhamento.

Na tela seguinte você deve colocar as credenciais da rede WiFi, nome e senha, na qual o relé irá estar conectado.

Clique em Next e o aplicativo irá iniciar a conexão do Relé wifi Sonoff com a rede Wifi.

Na tela seguinte você pode dar um nome ao seu dispositivo.

Clique em Complete Add. Agora seu dispositivo está configurado para ser controlado pelo aplicativo. Clique no botão liga/desliga para controlar o relé.

Clique no Nome do dispositivo para abrir mais opções como na tela seguinte.

No aplicativo também existem opções de temporizador e cronômetro. Você ainda pode compartilhar seu dispositivo para que outras pessoas possam controlá-lo.

Veja o Relé Wifi Sonoff em ação.

Gostou? Ajude-nos a melhorar o blog atribuindo uma nota a este tutorial (estrelas no final do artigo), comente e visite nossa loja FILIPEFLOP!

Site: Blog FILIPEFLOP

Apresentando a FRDM-KL05Z

Com relação à FRDM-KL05Z, fizemos aqui no blog algo inusitado: Primeiro mostramos como usar a placa, e depois, agora, falamos um pouco mais sobre ela!

Curiosidades à parte, podemos começar falando dela da seguinte forma: Se de um lado temos a FRDM-K64F que é um poderoso canhão embarcado, temos do outro lado um membro da família um pouco mais simples, mas que nem por isso deve ser subestimado! A FRDM-KL05Z veio para ser uma porta de entrada para quem quer se aventurar na arquitetura ARM no desenvolvimento de aplicações de baixo consumo.

O coração da KL05Z

O coração da KL05Z é o microcontrolador MKL05Z32VFM4, um ARM Cortex-M0+ Kinetis da série L, voltado para aplicações de baixo consumo de energia. Dentre os seus atributos, podemos citar:

• Frequência de operação de 48 MHz
• 32 KB de Memória Flash
• 4 KB de Memória RAM
• Encapsulamento de 32 pinos QFN
• 9 Modos de Baixo Consumo
• 41 sinais GPIO
• Interface para Sensor Touch de baixo consumo
• Alimentação de energia com 1.8 V (até 1.71 V considerando a tolerância)
• Comunicação
  • 1 Módulo SPI
  • 1 Módulo UART de baixo consumo
  • 1 Módulo I2C
• Módulos Analógicos
  • Conversor Analógico-Digital SAR de 12-bits
  • Conversor Digital-Analógico de 12-bit
• Timers
  • Timer/PWM de 6 canais
  • 1 Módulo Timer/PWM de 2 canais
  • Relógio de Tempo Real
  • Timer de baixo consumo de 16-bits
  • Timers de Interrupção Periódica

A Irmandade

Na FILIPEFLOP há também um irmão um pouco mais aprimorado da KL05Z, que é a KL25Z, apresentada por mim mesmo nesse artigo. Ambas são ARM voltadas para aplicações de baixo consumo, porém, a KL25Z possui alguns recursos a mais, como USB OTG, 128 KB de Flash e 16 KB de RAM, além de ter um encapsulamento de 80 pinos LQFP.

A diferença de pinos entre um e outro também se reflete na respectiva placa FRDM. Se você observar bem, verá que a FRDM-KL05Z possui uma pinagem nos moldes do Arduino R3, sendo que já a FRDM-KL25Z possui fileiras duplas de sinais em ambos os lados.

Pensando nisso, você deve se perguntar… Se há um, por quê o outro? Simples: Aplicações.

Se você quer um substituto tunado de um “Arduino R3″, a FRDM-KL05Z é uma ótima escolha. Porém, se você precisa de recursos como USB e mais sinais de interface e controle,  a FRDM-KL25Z será uma melhor escolha.

A FRDM-KL05Z

Como mencionado anteriormente, a FRDM-KL05Z é a placa que expõe e facilita o acesso aos recursos do MKL05Z32VFM4, ou KL05Z. Dessa forma, a placa possui regulador de energia, cristal, alimentação via USB, expõe os sinais de interface para comunicação e IOs, agregando alguns mimos a mais, tais como acelerômetro de 3 eixos MMA8451Q, led RGB e Touch Slider – Sim, a KL05Z possui, assim como a KL25Z, capacidade para lidar com entradas de sinais capacitivos.

Assim como as demais placas FRDM, a FRDM-KL05Z também possui um depurador OpenSDA integrado, que basicamente é um microcontrolador K20 “programado para programar”.

Dessa forma, além de não precisar de nenhum hardware adicional para programar o microcontrolador, o depurador OpenSDA também permite que você veja em tempo-real a execução de programas no microcontrolador, identificando o valor de variáveis, fluxo do programa, etc, o que é algo que vem muito a calhar em situações diversas no desenvolvimento de sistemas embarcados.

Esse mesmo depurador é usado na ferramenta MBED para gravar no microcontrolador o código gerado pela ferramenta online. Infelizmente, o MBED ainda não possui, até o presente momento, o recurso para depuração do código em execução. Para utilizar desse recurso é preciso usar ferramentas como a IDE Kinetis Design Studio.

Pinagem Arduino Uno R3

Uma das características que dei bastante destaque é a compatibilidade com a pinagem Arduino UNO R3. Não é pra menos: Os projetistas respeitaram minuciosamente a ordem dos sinais, como pode ser observado na figura abaixo, ou seja, desde a parte de alimentação, passando pelas entradas analógicas, e até mesmo a parte de sinais digitais, Serial UART, I2C/SPI e PWM.

Além disso, essa compatibilidade com Arduino UNO R3 torna possível utilizar shields Arduino com a FRDM-KL05Z.

Mimos Adicionais

Dentre os mimos adicionais que foram mencionados anteriormente, temos um LED RGB, Touch Slider capacitivo e um acelerômetro de 3 eixos. Na figura abaixo esses 3 itens aparecem em destaque.

Interessante observar a pinagem exposta, pois é a pinagem que deve ser usada para o acesso a esses recursos. Em próximos posts, irei mostrar como acessar o LED RGB, o Touch Slider Capacitivo e o Acelerômetro, respectivamente.

Destaque para o acelerômetro e LED RGB da KL05Z.

Aplicações

Eu, pessoalmente, mentalizo essa placa como um bom substituto do Arduino UNO R3. Se dificuldade de programação é uma bandeira vez ou outra levantada no que diz respeito aos microcontroladores ARM, isso não vem mais ao caso com o desenvolvimento usando MBED. Além do mais, mesmo usando Kinetis Design Studio há uma série de utilitários que facilitam o desenvolvimento para microcontroladores ARM Kinetis.

Com base na FRDM-KL05Z, cito os possíveis exemplos de aplicação, tendo por base seu apelo de baixo consumo:

• Robótica Móvel
  • Com 8 sinais de PWM é possível controlar servo-mecanismos e intensidade de Ponte-H, elementos usados na movimentação de robôs.
  • Possui acelerômetro embutido na placa – Sensor de inclinação para robô
• Sensoriamento Remoto
  • Por ter 9 modos de baixo consumo e periféricos projetados para baixo consumo de energia, pode ser programada para operar por longos períodos de tempo colhendo dados de sensores diversos.
• Automação Residencial – Domótica
  • Dependendo do tipo de equipamento utilizado em domótica, ele pode operar à bateria. Seja um relé, sensor de presença ou sensor de temperatura/umidade, etc. E para durar mais tempo nesse cenário, é bom que o consumo seja o menor possível.
• Aprendizado de Microcontroladores ARM
  • Como professor, recomendo ela sem sombra de dúvida para cursos de Sistemas Embarcados e treinamentos em geral.  É barata, prática, e compatível com Shields Arduno.

Gostou? Ajude-nos a melhorar o blog atribuindo uma nota a este tutorial (estrelas no final do artigo), comente e visite nossa loja FILIPEFLOP!

Site: Blog FILIPEFLOP

Planta IoT com ESP8266 NodeMCU – Parte 4

Hoje vamos dar continuidade a série de posts sobre a Planta IoT com ESP8266 NodeMCU, uma planta conectada à internet que avisa no seu celular quando precisa ser regada. Nesta continuação, a planta não vai somente avisar quando precisa ser regada, mas sim vai se regar sozinha! Ou seja, através de conceitos IoT, a planta irá reportar a situação da umidade de solo e, sem você precisar tomar ação alguma, ela irá se regar se necessário. Portanto, trata-se de uma solução ideal para você que precisa se ausentar de sua casa com frequência e quer que suas plantas fiquem bem cuidadas.

Se você perdeu os “episódios anteriores” do projeto Planta IoT com ESP8266 NodeMCU, acesse os links abaixo:

• Planta IoT com ESP8266 NodeMCU – Parte 1 (Monitoramento da planta IoT com ThingSpeak)
• Planta IoT com ESP8266 NodeMCU – Parte 2 (Envio de avisos pelo Twitter)
• Planta IoT com ESP8266 NodeMCU – Parte 3 (Integração com MQTT)

Como a planta IoT vai se auto regar?

Para a planta IoT se auto regar, iremos utilizar um hardware adicional ao projeto: a Válvula de Vazão Solenóide Água 12VDC. Esta válvula permite, através de um sinal de controle de 12V, liberar ou restringir o fluxo de água por ela. Em outras palavras, é como uma “torneira acionada eletricamente”. Portanto, em termos de hardware, iremos precisar utilizar tal válvula e um circuito para permitir o acionamento da mesma sem danificar o NodeMCU (para mais informações sobre os limites elétricos do NodeMCU, lesta este nosso post).

A regra para a planta se auto regar é simples: de trinta em trinta segundos (período de envio da umidade do solo ao ThingSpeak) é verificada se a umidade do solo é menor ou igual que o limite para regar (valor configurável no código, mas com default 30%). Em caso positivo, a válvula de vazão solenóide de água é acionada no tempo configurado (default de dois segundos).

Lista de componentes e circuito esquemático

O circuito completo do projeto utilizará os seguintes componentes:

• NodeMCU (ou o Kit Controle e Monitoramento IoT com ESP8266)
• Válvula de vazão solenóide água 12VDC
• Fonte DC chaveada 12V 2A (metálica)
• Sensor de umidade do solo higrômetro
• Resistor 1K 1/4W
• Resistor 2K 1/4W
• Protoboard (preferencialmente de 830 pontos)
• Transistor BC337
• Diodo 1N4007
• Jumpers diversos
• Fios e plug para tomada
• Mangueiras e conexões hidráulicas (para ligação da válvula à uma torneira)

O circuito esquemático pode ser visto abaixo:

Atenção: fazer as ligações da fonte 12V conforme ilustra a imagem a seguir. Observar que a ligação deve ser feita em rede 110V e que em L deve ser ligada a fase e em N o neutro (do ponto de energia / tomada que você estiver ligando a fonte).

Código-fonte

O código fonte do projeto planta IoT com ESP8266 NodeMCU pode ser visto a seguir. Observe com atenção os defines LIMITE_UMIDADE_PARA_REGAR (este valor determina qual será o limite percentual inferior da umidade do solo para a planta se regar) e TEMPO_PARA_REGAR (aqui é determinado por quanto tempo a válvula de vazão solenóide de água será acionada). Altere-os conforme seu gosto e necessidade.

//Programa: Planta IoT com ESP8266 NodeMCU e MQTT
#include <ESP8266WiFi.h>  //essa biblioteca já vem com a IDE. Portanto, não é preciso baixar nenhuma biblioteca adicional
#include <PubSubClient.h> // Importa a Biblioteca PubSubClient

//defines - mapeamento de pinos do NodeMCU
#define D0    16
#define D1    5
#define D2    4
#define D3    0
#define D4    2
#define D5    14
#define D6    12
#define D7    13
#define D8    15
#define D9    3
#define D10   1
 
//defines
#define SSID_REDE     " "  //coloque aqui o nome da rede que se deseja conectar
#define SENHA_REDE    " "  //coloque aqui a senha da rede que se deseja conectar
#define INTERVALO_ENVIO_THINGSPEAK  30000  //intervalo entre envios de dados ao ThingSpeak (em ms)
#define INTERVALO_ENVIO_MQTT        10000  //intervalo entre envios de dados via MQTT (em ms)
#define LIMITE_UMIDADE_PARA_REGAR   30     //limite percentual inferior para a planta se auto regar
#define TEMPO_PARA_REGAR            2000   //tempo (em ms) ao qual a válvula de vazão solenóide de água será acionada quando for necessário regar a planta 
#define SAIDA_COMANDO_VALVULA       D0     //saída do NodeMCU que acionará a válvula de vazão solenóide de água
  
//defines de id mqtt e tópicos para publicação e subscribe
#define TOPICO_SUBSCRIBE "MQTTFFPlantaIoTEnvia"     //tópico MQTT de escuta
#define TOPICO_PUBLISH   "MQTTFFPlantaIoTRecebe"    //tópico MQTT de envio de informações para Broker
                                                  //IMPORTANTE: recomendamos fortemente alterar os nomes
                                                  //            desses tópicos. Caso contrário, há grandes
                                                  //            chances de você controlar e monitorar o NodeMCU
                                                  //            de outra pessoa.
#define ID_MQTT  "PlantaIotParte3"     //id mqtt (para identificação de sessão)
                                       //IMPORTANTE: este deve ser único no broker (ou seja, 
                                       //            se um client MQTT tentar entrar com o mesmo 
                                       //            id de outro já conectado ao broker, o broker 
                                       //            irá fechar a conexão de um deles).
  
//constantes e variáveis globais
const char* BROKER_MQTT = "iot.eclipse.org"; //URL do broker MQTT que se deseja utilizar
int BROKER_PORT = 1883;                      // Porta do Broker MQTT
char EnderecoAPIThingSpeak[] = "api.thingspeak.com";
String ChaveEscritaThingSpeak = " ";        //coloque aqui sua chave de escrita do seu canal no ThingSpeak
long lastConnectionTime; 
long lastMQTTSendTime;
WiFiClient client;
WiFiClient clientMQTT;
PubSubClient MQTT(clientMQTT); // Instancia o Cliente MQTT passando o objeto clientMQTT
  
//prototypes
void EnviaInformacoesThingspeak(String StringDados);
float FazLeituraUmidade(void);
void initWiFi(void);
void initMQTT(void);
void reconectWiFi(void); 
void mqtt_callback(char* topic, byte* payload, unsigned int length);
void VerificaConexoesWiFIEMQTT(void); 
 
/*
 * Implementações
 */
  
//Função: envia informações ao ThingSpeak
//Parâmetros: String com a  informação a ser enviada
//Retorno: nenhum
void EnviaInformacoesThingspeak(String StringDados)
{
    if (client.connect(EnderecoAPIThingSpeak, 80))
    {         
        //faz a requisição HTTP ao ThingSpeak
        client.print("POST /update HTTP/1.1\n");
        client.print("Host: api.thingspeak.com\n");
        client.print("Connection: close\n");
        client.print("X-THINGSPEAKAPIKEY: "+ChaveEscritaThingSpeak+"\n");
        client.print("Content-Type: application/x-www-form-urlencoded\n");
        client.print("Content-Length: ");
        client.print(StringDados.length());
        client.print("\n\n");
        client.print(StringDados);
    
        lastConnectionTime = millis();
        Serial.println("- Informações enviadas ao ThingSpeak!");
     }   
}
  
//Função: inicializa e conecta-se na rede WI-FI desejada
//Parâmetros: nenhum
//Retorno: nenhum
void initWiFi() 
{
    delay(10);
    Serial.println("------Conexao WI-FI------");
    Serial.print("Conectando-se na rede: ");
    Serial.println(SSID_REDE);
    Serial.println("Aguarde");
      
    reconectWiFi();
}
   
//Função: inicializa parâmetros de conexão MQTT(endereço do 
//        broker, porta e seta função de callback)
//Parâmetros: nenhum
//Retorno: nenhum
void initMQTT() 
{
    MQTT.setServer(BROKER_MQTT, BROKER_PORT);   //informa qual broker e porta deve ser conectado
    MQTT.setCallback(mqtt_callback);            //atribui função de callback (função chamada quando qualquer informação de um dos tópicos subescritos chega)
}
   
//Função: função de callback 
//        esta função é chamada toda vez que uma informação de 
//        um dos tópicos subescritos chega)
//Parâmetros: nenhum
//Retorno: nenhum
void mqtt_callback(char* topic, byte* payload, unsigned int length) 
{
         
}
   
//Função: reconecta-se ao broker MQTT (caso ainda não esteja conectado ou em caso de a conexão cair)
//        em caso de sucesso na conexão ou reconexão, o subscribe dos tópicos é refeito.
//Parâmetros: nenhum
//Retorno: nenhum
void reconnectMQTT() 
{
    while (!MQTT.connected()) 
    {
        Serial.print("* Tentando se conectar ao Broker MQTT: ");
        Serial.println(BROKER_MQTT);
        if (MQTT.connect(ID_MQTT)) 
        {
            Serial.println("Conectado com sucesso ao broker MQTT!");
            MQTT.subscribe(TOPICO_SUBSCRIBE); 
        } 
        else
        {
            Serial.println("Falha ao reconectar no broker.");
            Serial.println("Havera nova tentatica de conexao em 2s");
            delay(2000);
        }
    }
}
   
//Função: reconecta-se ao WiFi
//Parâmetros: nenhum
//Retorno: nenhum
void reconectWiFi() 
{
    //se já está conectado a rede WI-FI, nada é feito. 
    //Caso contrário, são efetuadas tentativas de conexão
    if (WiFi.status() == WL_CONNECTED)
        return;
          
    WiFi.begin(SSID_REDE, SENHA_REDE); // Conecta na rede WI-FI
      
    while (WiFi.status() != WL_CONNECTED) 
    {
        delay(100);
        Serial.print(".");
    }
    
    Serial.println();
    Serial.print("Conectado com sucesso na rede ");
    Serial.print(SSID_REDE);
    Serial.println("IP obtido: ");
    Serial.println(WiFi.localIP());
}
  
//Função: verifica o estado das conexões WiFI e ao broker MQTT. 
//        Em caso de desconexão (qualquer uma das duas), a conexão
//        é refeita.
//Parâmetros: nenhum
//Retorno: nenhum
void VerificaConexoesWiFIEMQTT(void)
{
    if (!MQTT.connected()) 
        reconnectMQTT(); //se não há conexão com o Broker, a conexão é refeita
      
     reconectWiFi(); //se não há conexão com o WiFI, a conexão é refeita
}
  
//Função: faz a leitura do nível de umidade
//Parâmetros: nenhum
//Retorno: umidade percentual (0-100)
//Observação: o ADC do NodeMCU permite até, no máximo, 1V. Dessa forma,
//            para 1V, obtem-se (empiricamente) 418 como leitura de ADC
float FazLeituraUmidade(void)
{
    int ValorADC;
    float UmidadePercentual;
  
     ValorADC = analogRead(0);   //418 -> 1.0V
     Serial.print("[Leitura ADC] ");
     Serial.println(ValorADC);
  
     //Quanto maior o numero lido do ADC, menor a umidade.
     //Sendo assim, calcula-se a porcentagem de umidade por:
     //      
     //   Valor lido                 Umidade percentual
     //      _    0                           _ 100
     //      |                                |   
     //      |                                |   
     //      -   ValorADC                     - UmidadePercentual 
     //      |                                |   
     //      |                                |   
     //     _|_  418                         _|_ 0
     //
     //   (UmidadePercentual-0) / (100-0)  =  (ValorADC - 418) / (-418)
     //      Logo:
     //      UmidadePercentual = 100 * ((418-ValorADC) / 418)  
       
     UmidadePercentual = 100 * ((418-(float)ValorADC) / 418);
     Serial.print("[Umidade Percentual] ");
     Serial.print(UmidadePercentual);
     Serial.println("%");
  
     return UmidadePercentual;
}
void setup()
{  
    Serial.begin(9600);
    lastConnectionTime = 0; 
    lastMQTTSendTime = 0;
    initWiFi();
    initMQTT();
    pinMode(SAIDA_COMANDO_VALVULA,OUTPUT);
    digitalWrite(SAIDA_COMANDO_VALVULA,LOW);  //por default, a válvula de vazão solenóide de água começa fechada    
    Serial.println("Planta IoT com ESP8266 NodeMCU");
}
  
//loop principal
void loop()
{
    float UmidadePercentualLida;
    int UmidadePercentualTruncada;
    char FieldUmidade[11];
    char MsgUmidadeMQTT[50];
      
    VerificaConexoesWiFIEMQTT(); 
      
    //Força desconexão ao ThingSpeak (se ainda estiver desconectado)
    if (client.connected())
    {
        client.stop();
        Serial.println("- Desconectado do ThingSpeak");
        Serial.println();
    }
  
    UmidadePercentualLida = FazLeituraUmidade();
    UmidadePercentualTruncada = (int)UmidadePercentualLida; //trunca umidade como número inteiro
      
    //verifica se está conectado no WiFi e se é o momento de enviar dados ao ThingSpeak
    if(!client.connected() && 
      ((millis() - lastConnectionTime) > INTERVALO_ENVIO_THINGSPEAK))
    {
        sprintf(FieldUmidade,"field1=%d",UmidadePercentualTruncada);
        EnviaInformacoesThingspeak(FieldUmidade);
    }
  
    //verifica se é o momento de enviar informações via MQTT
    if ((millis() - lastMQTTSendTime) > INTERVALO_ENVIO_MQTT)
    {
        sprintf(MsgUmidadeMQTT,"- Umidade do solo: %d porcento.",UmidadePercentualTruncada);
        MQTT.publish(TOPICO_PUBLISH, MsgUmidadeMQTT);
        lastMQTTSendTime = millis();
    }

    //verifica se a planta deve ser regada
    if (UmidadePercentualTruncada <= LIMITE_UMIDADE_PARA_REGAR)
    {
        //em caso positivo, a planta é regada no tempo contido no define TEMPO_PARA_REGAR
        digitalWrite(SAIDA_COMANDO_VALVULA,HIGH);  //abre a válvula de vazão solenóide de água
        delay(TEMPO_PARA_REGAR);
        digitalWrite(SAIDA_COMANDO_VALVULA,LOW);  //fecha a válvula de vazão solenóide de água
    }
     
    delay(1000);
}

Abaixo você confere o projeto da Planta IoT em ação!

Gostou ? Ajude-nos a melhorar o blog atribuindo uma nota a este tutorial (estrelas no final do artigo), comente e visite nossa loja FILIPEFLOP!

Site: Blog FILIPEFLOP

Aprenda a usar o Sensor de frequência cardíaca

Para quem utiliza o Arduino somente para projetos em Automação Residencial e robótica, agora vai conhecer mais uma aplicação muito interessante: medir os batimentos do seu coração usando um Sensor de Frequência Cardíaca.

Como funciona o sensor de frequência cardíaca

Este módulo contém sensor de frequência cardíaca combinado um sensor óptico com amplificador, que envia o sinal analógico para o microcontrolador. Além disso, seu tamanho é bem reduzido (16 x 2,7mm), possui baixo consumo de energia (cerca de 4mA) e sua tensão de operação é de 3~5V, ideal para projetos Wearables com plataforma Arduino (Lilypad, Lilytiny, Flora, Gemma, Pro Mini, etc).

Pode ser usado em projetos para medir níveis de atividade, ansiedade ou até mesmo fazer com que um wearable faça um efeito de pisca conforme os batimentos cardíacos. Makers, profissionais de eletrônica, atletas e desenvolvedores de aplicativos e jogos podem fazer uso deste sensor de maneira fácil e rápida.

Vamos utilizar o sensor para piscar um led conforme os batimentos cardíacos.

Lista de material

• Placa Nano (ou qualquer outro Arduino de sua preferência)
• Sensor de frequência cardíaca
• Led 5mm vermelho (ou qualquer cor que desejar)
• Resistor 220R
• Protoboard
• Jumpers macho-macho
• Ferro de solda e estanho

Montagem do circuito Sensor de Frequência Cardíaca e Arduino

Primeiramente solde três pinos nos pads do sensor de pulso. Caso queira, substitua os pinos por fios.

Neste sensor, temos o pad à esquerda como sinal (S), central como positivo (+) e à direita como GND (-).

Encaixe o Arduino Nano na parte central do protoboard. Conecte o sensor conforme a figura abaixo:

O sinal de saída do sensor foi conectado ao pino A0, (+) no 5V e (-) no GND.

O sketch para funcionamento do programa foi disponibilizado no GitHub aqui. Realize o download e abra a IDE Arduino. Abra o arquivo PulseSensorAmped_Arduino_XYZ (XYZ é a versão do programa, que pode ter sido modificada desde o lançamento deste post). Carregue o programa para o Arduino:

O circuito montado em protoboard ficará parecido com este:

Depois de verificar as conexões e carregar o sketch, você vai verificar que o sensor ficará aceso com cor verde, referente ao seu sensor óptico como na próxima imagem:

Encoste o dedo sobre a parte onde está o coração branco no sensor e veja o led piscando conforme seus batimentos cardíacos:

Dica: Uma sugestão para utilização deste sensor é colocar o dedo sobre o sensor com um pedaço de velcro para obter melhor desempenho. Também pode ser adaptado a um clipe para por sobre a orelha.

Um passo adiante com o sensor é visualizar a forma de onda gerada em um código no Processing. Neste tutorial você pode desenvolver esta aplicação.

Gostou? Ajude-nos a melhorar o blog atribuindo uma nota a este tutorial (estrelas no final do artigo), comente e visite nossa loja FILIPEFLOP!

Site: Blog FILIPEFLOP

Concorra a 4 Relés WiFi Sonoff

Automatizar a sua casa está mais fácil do que você imagina, e sem muito conhecimento de prototipagem, você pode encarar um projeto que vai impressionar. Então, já aguce a criatividade porque este mês sortearemos quatro Relés WiFi Sonoff. O Sonoff é muito prático e você consegue em poucos minutos e sem configurações complicadas, acioná-lo remotamente através de rede wireless. Chegou a hora de você transformar sua casa em uma smart home, controlando equipamentos e eletrodomésticos por um aplicativo de celular. Sem muitas ideias de como fazer isso? Você pode assistir alguns episódios dos Jetsons para buscar inspiração ou acessar o post em que ensinamos como acender as luzes pelo celular utilizando o Relé WiFi Sonoff. Acesse AQUI, e veja abaixo Relé em ação.

COMO PARTICIPAR

Quer participar mas não sabe como? A gente te explica. É super fácil. Basta responder à pergunta no aplicativo abaixo e curtir nossa Fanpage no Facebook para não perder o resultado. Não esqueça de preencher seu nome completo para validação da participação.

a Rafflecopter giveaway

RESULTADO SORTEIO 4 RELÉS WIFI SONOFF

Você tem até às 23:59h do dia 25 de junho de 2017 para participar. O resultado será divulgado no dia 26 de junho de 2017 às 11h, neste blogpost e no Facebook da FilipeFlop. Serão sorteados 4 Relés WiFi Sonoff, ou seja, serão quatro vencedores contemplados com um Sonoff cada um.

O vencedor será comunicado do resultado através do email por ele cadastrado, no qual será solicitado o envio dos seus dados cadastrais: nome completo, CPF, email, endereço e telefone. Caso o vencedor não responda ao nosso contato em até 48 horas, um novo sorteio será realizado.

Boa sorte

Site: Blog FILIPEFLOP

Robô brasileiro é selecionado no Japão

O incentivo da tecnologia nas escolas e faculdades brasileiras, viabiliza que ela se espalhe em forma de educação e descubra “gênios” dentro do nosso país. Um exemplo disso é o Instituto Federal de Tocantins que incentiva seus alunos a criarem projetos e levarem em frente suas ideias. O programador e estudante de engenharia Arthur Martins projetou um robô, juntamente com sua equipe de estudantes do IFTO, que simula um tanque de guerra. O robô possui uma micro câmera, que capta todas as imagens que vê e as transmite por códigos. Ele foi criado para enfrentar desafios com níveis altos de dificuldade em uma área de resgate.

Arthur Martins, idealizador do projeto, explica como funciona este robô:

– Imagina um terreno como se fosse uma montanha, mas uma montanha que não tem um formato físico. São cubinhos de madeira 5cm x 5cm, todos espalhados aleatoriamente. Ele tem que andar por cima dos cubinhos e achar o QR code para poder ler. Tem uma informação de áudio relacionada a cada QR code.

Os alunos do IFTO ficaram 8 meses em cima do projeto para finalizar todos os detalhes técnicos. O professor, que da aula de mecatrônica, considera o robô o projeto mais evoluído criado até hoje por alunos da instituição.

Wendell Eduardo, professor e curador desse projeto diz que ” Desde o ano passado a gente tem desenvolvido trabalhos aqui na área de robótica, especificamente este projeto. Os alunos tem trabalhado nele desde outubro. A gente vem trabalhando na montagem e na programação.”.

Site: Blog FILIPEFLOP

Intel Galileo Gen2 com nova imagem em microSD

“Recentemente” a Intel liberou uma imagem Linux atualizada para a Intel Galileo Gen1 e Gen2 – Lembrando que a Intel Galileo Gen2 está disponível na FILIPEFLOP – contendo algumas melhorias e atualizações para o sistema dessa incrível placa.

Para quem não sabe, a Intel Galileo Gen2 roda Linux em um processador Intel Quark X1000, operando a 400 MHz com 256 MB de RAM. Em outras palavras, é um processador x86 para aplicações embarcadas de controle e automação. Ou seja, ela é bem mais poderosa do que um tradicional Arduino da vida. Você pode executar um simples Sketch de Arduino nela, ou escrever um programa em Python com banco de dados e conexão com serviços na nuvem, por exemplo, fazendo uso do sistema Linux que ela executa.

O Adilson Thomsen já escreveu sobre a Galileo Gen2 aqui no Blog FILIPEFLOP, a saber:

• Primeiros Passos com Galileo Gen2 – Mostra como instalar e configurar o Arduino IDE para fazer interface de comunicação e programação com a placa.
• Trabalhando com Linux e Python no Intel Galileo Gen2 – Mostra como instalar o sistema Linux em cartão para usar Python com a Galileo Gen2.

Todavia, dos tempos desses artigos para cá a Intel realizou atualizações na imagem, e o próprio processo de gravação da imagem em cartão foi modificado também. Assim, irei mostrar como gravar a imagem de cartão e como localizar a Intel Galileo Gen2 na rede.

“André, mas a Galileo já não vem com Linux na memória interna dela?” – Sim, fato. Mas a memória interna dela é pequena, bem pequena: 8 MB. Suficiente apenas para rodar alguns scripts e executar os binários de Arduino, por exemplo. Se você quiser algo mais “requintado”, por assim dizer, terá que usar uma imagem gravada em cartão de memória!

E mais: Com essa imagem atualizada é possível instalar o Python, bibliotecas como OpenCV, executar NodeJS, dentre outros. Ou seja, você terá muito mais funcionalidades com a placa, indo além do tradicional Arduino.

Receita de Bolo

Para esse artigo, iremos usar os seguintes itens e ferramentas:

• Intel Galileo Gen2 com fonte de alimentação, cabo de rede Ethernet;
• Roteador com uma porta Ethernet disponível;
• Cartão microSD – recomendo pelo menos 4 GB ou 8 GB;
• Imagem Linux Poky para Intel Galileo Gen2;
• Programa Win32DiskImager
• Programa Advanced IP Scanner
• Programa Putty

Baixando e Gravando a imagem de cartão

O primeiro passo é ir na página de Downloads da Intel para a Galileo Gen2 – Disponível neste link. Nessa página é possível ter acesso ao link de download da imagem Linux Poky (feita com Yocto) para a Intel Galileo Gen2.

Figura 1 – Download da imagem Linux Poky para Intel Galileo Gen2. Fonte: Intel.com

Feito o download da imagem, no momento da escrita desse artigo, você terá um arquivo chamado iot-devkit-prof-dev-image-galileo-20160606.zip. Descompacte esse arquivo em um diretório de sua preferência, usando um WinZip, WinRAR ou 7zip da vida.

Quem já gravou imagens para Raspberry Pi ou correlatos da vida, deve estar esperando encontrar um arquivo com extensão *.img dentro desse arquivo *.zip compactado. Mas… A Intel colocou o arquivo com extensão *.direct! Não estranhe, está tudo certo, está tudo bem

Descompactado o arquivo que você baixou da Intel, você terá então um arranjo da seguinte forma:

Figura 2 – Arquivo de imagem com extensão *.direct da Intel Galileo Gen2.

O próximo passo agora é usar o Win32DiskImager para gravar a imagem que baixamos de cartão na Intel Galileo Gen2. O programa está disponível no SourceForge neste link. A instalação é OK, o típico “procedimento padrão” – próximo, próximo, etc.

Instalado o programa, insira o cartão microSD usando um adaptador USB ou um adaptador de cartão SD, caso esteja usando um notebook com entrada para cartão, por exemplo.

Agora, abra o programa Win32DiskImager instalado no seu computador com Windows. Após abrir o programa, você irá observar uma janela tal como a mostrada na imagem da Figura 3 logo abaixo, com 2 itens que destaco para o nosso processo:

• 1o Item – ícone para abrir a janela de seleção para o arquivo de imagem a ser gravado.
• 2o Item – Lista de seleção para unidade de disco (ou cartão…) onde será gravada a imagem.

Figura 3 – Win32DiskImager – Pontos a observar.

Clique no ícone indicado pelo número 1 da Figura 3, e irá abrir uma janela do Windows Explorer para você selecionar a imagem que usaremos para gravar o cartão microSD. Como padrão, o programa espera encontrar arquivos no formato *.img, mas a nossa imagem está no formato *.direct, lembram? Assim, clique na lista de seleção destacada no canto inferior direito da Figura 4 e selecione a opção *.* para que o programa exiba todos os arquivos. Selecione então a imagem iot-devkit-prof-dev-image-galileo-20160606.direct, no local em que foi descompactada, e clique em Open.

Figura 4 – Win32DiskImager – Seleção da imagem da Intel Galileo Gen2.

Feito isso, ATENÇÃO: Vamos selecionar a unidade de disco no campo “Device” do Win32DiskImager, conforme destacado no item 2º da Figura 3. Verifique pelo Windows Explorer qual é a unidade de disco do microSD que você inseriu no seu computador. No meu caso, o Windows Explorer identificou a unidade como sendo a G:. Isso é muito importante porque o programa irá sobrescrever os dados da unidade (ou cartão), gravando a imagem que selecionamos. Se você selecionou a unidade certa, OK. Mas se selecionar a errada… Aí é uma dor de cabeça. Então, atenção nessa parte!

Vejam na Figura 5 que meu cartão microSD inserido no computador foi identificado como um “USB Drive”, como unidade G:

Figura 5 – Windows Explorer identificou microSD inserido no computador.

Feito isso, deixe marcado então no campo Device a unidade correspondente ao cartão microSD no seu computador, e agora vem o ponto-chave: A gravação! Clique no botão Write, conforme indicado na Figura 6, para que o programa faça então o processo de gravar o arquivo de imagem no cartão microSD. Paciência, pois esse processo pode demorar uns bons minutos.

Figura 5 – Win32DiskImager – Gravação da imagem no cartão microSD.

Como o processo irá sobrescrever os arquivos da unidade selecionada, o programa irá exibir um aviso tal como o da imagem da Figura 6. Clique em Yes caso tenha selecionado corretamente a unidade e tenha certeza em continuar com o processo.

Figura 6 – Aviso de gravação do Win32DiskImager.

 Agora é esperar…

Figura 7 – Win32DiskImager – Gravando a imagem no cartão microSD.

Se tudo correu bem, e assim esperamos que corra bem, o programa irá exibir ao final uma janela tal como a mostrada na Figura 8. Clique em OK.

Figura 8 – Win32DiskImager – Gravação realizada com sucesso.

Terminado, faça a remoção com segurança do adaptador USB/adaptador de cartão microSD (nos mesmos moldes que você faz – ou deveria fazer – com pendrives no Windows).

É importante remover com segurança para que o sistema finalize eventuais processos vinculados à unidade, o que reduz as chances de o cartão acabar sendo corrompido.

Startup e Conexão SSH com Galileo Gen2

Beleza, gravamos o cartão com a imagem mais nova, agora é hora de colocar ele na Galileo Gen2, ligar a placa e colocar ela na rede!

Primeiro – Insira o cartão microSD no conector para cartão microSD da Intel Galileo Gen2.

Segundo – Ligue o cabo de rede Ethernet no seu roteador e na Intel Galileo Gen2

Terceiro – Ligue o cabo de energia da fonte que acompanha a placa, e ligue a fonte na tomada para energizar a placa.

Antes, para sabermos o endereço IP da Intel Galileo e sermos capazes de acessar ela pela rede, era necessário gravar um Sketch de Arduino nela, capaz de ler os dados da rede e enviar via Serial.

Com essa nova imagem, o serviço de SSH já vem acionado por padrão no Linux Poky da Galileo Gen2. Isso significa que basta localizarmos o IP da placa na rede para podermos acessar o console do sistema Linux, e até mesmo termos acesso aos arquivos da placa, dentre outros.

Para localizarmos a placa na rede, iremos usar o programa Advanced IP Scanner, que é gratuito. Acesse o site do programa e clique no ícone verde Free Download, que irá levar você a uma outra página, específica para Download. Nessa página, clique no ícone verde no canto superior direito da página, Download Latest Version. Baixe e faça a instalação (procedimento padrão!). Esse programa tem um modo de operação “standalone”, ou seja, não instala – executa diretamente. Não recomendo… Como uso ele com frequência, deixo instalado já de cara, ok?

Abra o Advanced IP Scanner e clique no botão Scan, para que ele comece a procurar pelos dispositivos na sua rede local.

Figura 9 – Advanced IP Scanner.

A Intel Galileo Gen2 irá aparecer com o nome galileo.home, conforme mostrado na Figura 10. Observe ao lado do nome o endereço IP dela na rede, iremos usar esse endereço para acessá-la logo adiante.

Figura 10 – Intel Galileo Gen2 como galileo.home

A despeito de existirem diversos programas para acessar um sistema Linux via SSH, iremos usar o Putty por ser gratuito, simples e prático. Você pode baixar o programa nesta página – Selecione o putty-0.68-installer.msi para máquinas x86 ou o putty-64bit-0.68-installer.msi para máquinas x64. Faça o download e realize a instalação do programa logo em seguida. Terminada a instalação, abra o programa Putty.

O Putty já é aberto com a opção de acesso via SSH selecionada por padrão. Assim, no campo Host Name (IP), coloque o endereço IP da Intel Galileo Gen 2, localizado pelo Advanced IP Scanner. A porta de acesso é a 22, padrão do SSH. Feito isso, clique em Open para iniciar a conexão via SSH com o Linux Poky da Intel Galileo Gen2.

Figura 11 – Setup para acesso via SSH à Intel Galileo Gen2.

O protocolo SSH é uma forma segura para acesso a sistemas remotamente. De uma forma resumida, há uma troca de chaves que garantem um acesso autorizado ao sistema. Assim, na primeira vez que você for acessar o sistema Linux da Intel Galileo Gen2, no endereço IP informado, o Putty irá notificar a adição da chave de acesso, tal como mostrado na Figura 12. Clique em Yes para adicionar e continuar com o acesso. Caso a Intel Galileo Gen2 mude de endereço IP, haverá uma nova troca/adição de chaves, ok?

Figura 12 – Confirmação de chave para acesso remoto via SSH.

Com o acesso autorizado, a primeira mensagem que irá aparecer é um campo (login as: ) para você inserir o usuário o qual deseja usar no acesso. Por padrão, o Poky Linux da Intel Galileo Gen2 está com o usuário root, sem senha. Então, digite root e aperte a tecla ENTER. O acesso agora está garantido! Observe na Figura 13 como fica. Em termos de sistema Linux, o console será exibido como “root@galileo: ~#” – root por ser o usuário, galileo pelo nome da máquina (hostname), ~ é o diretório raiz, e # indica que o console está como super-usuário (root).

Figura 13 – Acesso via SSH à Intel Galileo Gen2 – Login como root.

Um panorama sobre o Poky Linux para Intel Galileo Gen2

Essa versão do Poky Linux para a Intel Galileo Gen2 está realmente fantástica! Para makers e desenvolvedores de plantão, é um prato cheio para a criação de aplicações em Java, Python, NodeJS e até C/C++, pois já vem com os compiladores/interpretadores instalados. Veja na Figura 14 uma “prova” disso.

Figura 14 – Poky Linux com muitos recursos!

Ela já vem até com servidor Web Lighttpd instalado e configurado. Acesse o endereço IP que você usou para acessá-la no Putty via SSH em um navegador. No meu caso, acessei o IP 192.168.1.35 no Firefox, e pude ver a mensagem “It works” exibida. Ficou curioso? Essa página está no diretório /www/pages da Intel Galileo. Eu editei o arquivo e olha só:

Figura 15 – Página web da Intel Galileo Gen2.

Alguns usuários começaram usando a Intel Galileo Gen2 no modo Arduino, mais purista… Brincando com a placa usando simplesmente o Arduino IDE. Mas ela tem muito mais recursos! Aventure-se pelo mundo de Linux Embarcado e explore o desenvolvimento de aplicações embarcadas em Java, C/C++, Python e NodeJS. Você pode criar mecanismos que controlam os recursos da Intel Galileo Gen2, ao mesmo tempo que realiza comunicação com serviços na nuvem tais como Azure, Amazon, etc.

Gostou? Ajude-nos a melhorar o blog atribuindo uma nota a este tutorial (estrelas no final do artigo), comente e visite nossa loja FILIPEFLOP!

Site: Blog FILIPEFLOP

Programação do ESP8266 via OTA com wifi

O módulo ESP8266 é outro divisor de águas que veio para ficar. Barato, prático, útil, esse microcontrolador com WiFi integrado pode ser programado pela sua SDK nativa, usando LUA e até mesmo com Arduino IDE. E agora, uma funcionalidade extremamente útil será apresentada: a gravação via WiFi, também chamada de OTA  (Over-The-Air) ou FOTA (Firmware Over-The-Air).

Gravação Over-The-Air (OTA)

Com o advento de dispositivos com comunicação sem-fio incorporada, seja Bluetooth, WiFi, GSM e até mesmo outros tipos, os fabricantes começaram a disponibilizar formas de programar o dispositivo por meio da comunicação sem-fio.

E qual o motivo de tanto “alarde” em prol dessa funcionalidade? É porque isso torna extremamente prático a atualização remota de equipamentos em campo. Pensa comigo: Você acabou de programar um sensor e colocou ele no forro da sua casa, monitorando o nível da caixa d’água, por exemplo. E de repente você lembrou que um parâmetro está errado e precisa ser corrigido… Sem atualização remota, você teria que subir no forro, desmontar o equipamento, ligar no seu computador, programar e remontar tudo.

Com atualização remota, se o equipamento está conectado (via WiFi, por exemplo), você é capaz de acessá-lo e reprogramá-lo! Dessa forma, não será necessário seu deslocamento nem o desmonte do equipamento para isso.

E olha que eu citei um exemplo bem simples, mas isso é usado por gente séria no mercado. Quer saber quem usa? A Tesla, por exemplo! Aquela grande fabricante de carros elétricos dos EUA. A atualização dos sistemas de seus veículos é feita remotamente por meio de GSM com conexões 3G/4G (depende do plano e do modelo do veículo).

Tendo por base um humilde NodeMCU com ESP8266, você pode remotamente atualizar o firmware do seu robô móvel do TCC, pode remotamente atualizar o firmware do sistema de domótica, controle de irrigação, monitoramento de caixas d’água, tangues, etc que está implementando, desde que o módulo esteja em uma mesma rede de acesso que seu computador.

Na FILIPEFLOP há uma outra plaquinha que é programada via WiFi por padrão, desde que a rede WiFi tenha conexão com a Internet – é a Particle Photon.

Neste exemplo, vou tratar do NodeMCU ESP8266 com Arduino IDE, tendo por base um cenário de rede WiFi com acesso local, ou seja, você e o NodeMCU estão numa mesma rede WiFi.

Setup Necessário

É de extrema importância que você tenha o Arduino instalado. De preferência, instale a última versão, que no momento de escrita desse artigo é a versão 1.8.2, e está disponível no site Arduino.cc.

Depois, faça a configuração do Arduino IDE para suportar o desenvolvimento com ESP8266  – Você pode fazer essa configuração tendo por base esse tutorial escrito no Blog FILIPEFLOP.

Para fazer uso da funcionalidade de gravação via WiFi, é necessário ter o Python 2.7.x instalado na sua máquina. Você pode baixar o instalador no site https://www.python.org/downloads ou  https://www.python.org/downloads/release/python-2710 para já ir na sessão de downloads da sequência 2.7.10. Tendo por base máquinas Windows, baixe o arquivo Windows x86-64 MSI Installer para máquinas 64-bits, ou Windows x86 MSI Installer para máquinas 32-bits.

Instalação do Python 2.7.x

Após baixar o instalador do Python 2.7.x adequado, abra o executável baixado para efetivamente instalar o Python e toda sua infraestrutura no Windows. O processo de instalação é simples, é o famoso “próximo->próximo->próximo”, mas é preciso atentar para dois pontos importantes do processo de instalação:

1 – Na primeira janela de opções, marque a opção de instalar o programa para todos os usuários

Figura 1 – Instalação do Python para todos os usuários.

2 – Logo depois, marque a opção para adicionar o python.exe ao PATH de sistema do Windows

Figura 2 – Adicionar Python ao PATH do Windows.

Feito isso, tudo OK para prosseguirmos!

Não adianta pular essa parte. Sem o Python, o plugin de ESP8266 para o Arduino não conseguirá fazer as chamadas para gravação remota, ok?

Gravação via OTA – A Base

O âmago da coisa é SEMPRE (e eu repito: SEMPRE) gravar os sketchs – nome bonito para “programa com Arduino” – com a estrutura do exemplo BasicOTA fornecido com o plugin de ESP8266 para o Arduino IDE.

As versões mais recentes do plugin ESP8266 passaram a vir com suporte para gravação remota via WiFi, sendo esse suporte (muito bem) exemplificado no sketch BasicOTA.

Se você já instalou o Arduino IDE, já configurou o suporte para ESP8266 e já instalou o Python na sua máquina, abra o programa Arduino IDE e selecione a placa NodeMCU 1.0 na opção “Boards”, para habilitar a listagem de exemplos para ESP8266.

Figura 3 – Arduino IDE – Seleção da placa NodeMCU 1.0 – ESP-12E.

Configure adequadamente a opção Port de acordo com a porta serial COM atribuída ao seu módulo NodeMCU no Windows.

Assim, veja então na Figura 4 como abrir esse exemplo.

Figura 4 – Arduino IDE – Seleção do Exemplo BasicOTA.

Eu tomei a liberdade de usar esse Sketch como base, e fiz algumas modificações com comentários em português. Veja o código desse exemplo abaixo, com meus comentários:

#include <ESP8266WiFi.h>
#include <ESP8266mDNS.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>

const char* ssid = "NOME DA SUA REDE WIFI";
const char* password = "SENHA DA SUA REDE WIFI";

void setup() {
  Serial.begin(115200);
  Serial.println("Iniciando...");
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  while (WiFi.waitForConnectResult() != WL_CONNECTED) {
    Serial.println("Conexao falhou! Reiniciando...");
    delay(5000);
    ESP.restart();
  }

  // Porta padrao do ESP8266 para OTA eh 8266 - Voce pode mudar ser quiser, mas deixe indicado!
  // ArduinoOTA.setPort(8266);

  // O Hostname padrao eh esp8266-[ChipID], mas voce pode mudar com essa funcao
  // ArduinoOTA.setHostname("nome_do_meu_esp8266");

  // Nenhuma senha eh pedida, mas voce pode dar mais seguranca pedindo uma senha pra gravar
  // ArduinoOTA.setPassword((const char *)"123");

  ArduinoOTA.onStart([]() {
    Serial.println("Inicio...");
  });
  ArduinoOTA.onEnd([]() {
    Serial.println("\nFim!");
  });
  ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
    Serial.printf("Progresso: %u%%\r", (progress / (total / 100)));
  });
  ArduinoOTA.onError([](ota_error_t error) {
    Serial.printf("Erro [%u]: ", error);
    if (error == OTA_AUTH_ERROR) Serial.println("Autenticacao Falhou");
    else if (error == OTA_BEGIN_ERROR) Serial.println("Falha no Inicio");
    else if (error == OTA_CONNECT_ERROR) Serial.println("Falha na Conexao");
    else if (error == OTA_RECEIVE_ERROR) Serial.println("Falha na Recepcao");
    else if (error == OTA_END_ERROR) Serial.println("Falha no Fim");
  });
  ArduinoOTA.begin();
  Serial.println("Pronto");
  Serial.print("Endereco IP: ");
  Serial.println(WiFi.localIP());
}

void loop() {
  ArduinoOTA.handle();
}

A biblioteca ESP8266WiFi.h cuida das chamadas para acesso à rede WiFi, propriamente. Já uma boa parte das chamadas diz respeito à ArduinoOTA.h, que cuida das chamadas para tratar o recebimento de código e autogravação via WiFi.

No início do código há 2 variáveis que armazenam o nome e senha da sua rede WiFi, ssid e password, respectivamente.

Na rotina void setup() é configurada a Serial (como forma de você acompanhar pela Serial se tudo está correndo bem ou não), o módulo é colocado no modo Station (ele se conecta à uma rede WiFi), e é começado todo um processo para configuração da gravação via OTA.

Como disse, tomei a liberdade de comentar algumas partes do código original em inglês para português.

Essa estrutura-base é o que vai permitir seu ESP8266 ser conectado à rede WiFi e ficar disponível, quando requisitado, para receber e auto-gravar o programa recebido via WiFi com o Arduino IDE. Sem essa estrutura, o Arduino IDE não irá localizar o módulo ESP8266, e a programação sem-fio não funcionará.

Gravando o primeiro firmware para OTA

Como seu NodeMCU ESP8266 ainda não está preparado para gravação via WiFi, é preciso prepará-lo, certo? Dessa forma, conecte o NodeMCU via USB ao seu computador. Configure seu Arduino IDE para placa NodeMCU V1.0 e selecione a porta serial atribuída ao NodeMCU pelo Windows. No meu caso, como mostrado no canto inferior direito da Figura 5, minha NodeMCU ficou com a porta COM3 no Windows.

No código-exemplo de BasicOTA, coloque nos campos ssid e password as informações para acesso à sua rede WiFi, e coloque o Arduino IDE para compilar e gravar o código no NodeMCU, via USB (afinal de contas, ele ainda não tem a estrutura para gravação via WiFi!). Para efeitos de segurança e privacidade, como manda a boa educação, não deixei esses dados à mostra

Figura 5 – Processo de gravação do BasicOTA no Arduino IDE.

Terminado o processo de gravação, tenha uma janela do Terminal Serial do Arduino aberta – é só clicar no ícone da Lupa no Arduino IDE, no canto superior direito – para ver o resultado (positivo ou não…) do processo de conexão do módulo à rede WiFi. Caso não apareça nada, aperte o botão Reset do NodeMCU para reiniciar o módulo e forçar a aparição das mensagens. Veja no meu caso como apareceu:

Figura 6 – Endereço IP do módulo na Rede.

Se correu tudo bem, o Arduino IDE agora é capaz de ver o endereço IP do NodeMCU ESP8266 pela rede. Não sei se isso é geral, mas comigo é preciso fechar o Arduino IDE e abrir o programa novamente, para que o endereço IP da placa apareça na listagem de Portas. Bom… Feito isso, veja como agora, na opção “Tools->Port” (Ou Ferramentas->Porta), e agora veja que além das portas Seriais, aparece também o módulo e seu endereço IP, na parte Network ports!

Figura 7 – NodeMCU agora consta como elemento de rede para gravação!

Porém… Esse código por si só não faz nada. Só deixa o módulo esperando algum comando de gravação remota.

Gravação via OTA – Exemplo

Sem tirar a estrutura-base do exemplo que começamos, principalmente no que tange às configurações que estão em setup(), mantenha a chamada ArduinoOTA.handle() no início da rotina loop().

Essa chamada ArduinoOTA.handle() é quem lida com as requisições para gravação de firmware remotamente. Ou seja, seu novo programa além de funcionar com a sua lógica específica (controle de relé, monitoramento de sensor, exibição de dados em display, etc!), ficará “atento” à requisições de gravações remotas.

Além da estrutura lógica do OTA, também é preciso manter as configurações de Rede WiFi (ssid e password) para que o módulo seja conectado na rede WiFi, ok?

Vejam abaixo como fica um programa com o esqueleto do BasicOTA, mas agora com uma lógica para controle de um LED conectado na GPIO 2, por exemplo:

#include <ESP8266WiFi.h>
#include <ESP8266mDNS.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>

const char* ssid = "Minha_rede_WiFi";
const char* password = "Senha_da_minha_rede_wifi";

void setup() {
  //Colocamos o sinal D4 (GPIO02) do NodeMCU como saida 
  pinMode(D4, OUTPUT);
  Serial.begin(115200);
  Serial.println("Iniciando...");
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  while (WiFi.waitForConnectResult() != WL_CONNECTED) {
    Serial.println("Conexao falhou! Reiniciando...");
    delay(5000);
    ESP.restart();
  }

  ArduinoOTA.onStart([]() {
    Serial.println("Inicio...");
  });
  ArduinoOTA.onEnd([]() {
    Serial.println("\nFim!");
  });
  ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
    Serial.printf("Progresso: %u%%\r", (progress / (total / 100)));
  });
  ArduinoOTA.onError([](ota_error_t error) {
    Serial.printf("Erro [%u]: ", error);
    if (error == OTA_AUTH_ERROR) Serial.println("Autenticacao Falhou");
    else if (error == OTA_BEGIN_ERROR) Serial.println("Falha no Inicio");
    else if (error == OTA_CONNECT_ERROR) Serial.println("Falha na Conexao");
    else if (error == OTA_RECEIVE_ERROR) Serial.println("Falha na Recepcao");
    else if (error == OTA_END_ERROR) Serial.println("Falha no Fim");
  });
  ArduinoOTA.begin();
  Serial.println("Pronto");
  Serial.print("Endereco IP: ");
  Serial.println(WiFi.localIP());
}

void loop() {
  // Mantenha esse trecho no inicio do laço "loop" - verifica requisicoes OTA
  ArduinoOTA.handle();
  digitalWrite(D4, HIGH); // Aciona sinal 2
  delay(2000); // Espera por 2 segundos
  digitalWrite(D4, LOW); // Apaga sinal 2
  delay(2000);  // Espera por 2 segundos
}

Apenas para dar uma noção da montagem, conectei um LED vermelho no sinal D4 (GPIO02) do NodeMCU, conforme mostrado no seguinte esquemático de Fritzing:

Figura 8 – Esquemático de Ligação com NodeMCU.

Para testar esse programa em execução no Arduino IDE, coloque o código com a estrutura mostrada acima (lembrando de substituir a parte de ssid/senha com os dados para acesso à sua rede WiFi), e selecione agora o módulo pelo seu endereço IP em Ferramentas->Portas (Tools->Ports) do Arduino IDE. Mande o Arduino compilar e gravar o código.

Lembra que tivemos que instalar o Python para realizar a gravação remota? Observe que após o Arduino IDE compilar o código e começar o processo de gravação, irá aparecer uma janela do Windows pedindo autorização para o Python acessar recursos da Rede. Autorize marcando as duas caixas de opções, para que tudo corra bem.

Figura 9 – Autorização do Python para acesso à rede em Windows.

Por fim, acompanhe o resultado. Veja que agora a gravação ocorrerá via WiFi – Observe a minha seleção no canto inferior direito do Arduino IDE, veja que o “Port” é o endereço IP do módulo NodeMCU!

Figura 10 – NodeMCU programado com Arduino IDE via WiFi!

Pelo fato de você ter gravado seu programa com a estrutura do OTA, será possível, assim, novamente gravar o ESP8266 via WiFi usando o Arduino, e assim sucessivamente, mantendo a estrutura!

Gostou ? Ajude-nos a melhorar o blog atribuindo uma nota a este tutorial (estrelas no final do artigo), comente e visite nossa loja FILIPEFLOP!

Site: Blog FILIPEFLOP

Projeto com Arduino cria ilusão hipnotizante

O Arduino foi criado em 2005 por um grupo de 5 pesquisadores : Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino e David Mellis. O objetivo era elaborar um dispositivo que fosse ao mesmo tempo barato, funcional e fácil de programar, sendo dessa forma acessível a estudantes e projetistas amadores. Já dá para imaginar quantos projetos geniais são possíveis com esta placa. Aqui em nosso blog você acessa uma enorme variedade de tutoriais e aprende o passo a passo para começar a desenvolver com este embarcado.

Arduino como objeto artístico

Agora já pensou em criar um projeto artístico utilizando Arduino? É exatamente isso que o projeto JF sLOMO propõe utilizando um kit da versão Nano, uma dupla de penas e uma moldura da IKEA. Ele aproveita o ambientação para criar o efeito de câmera lenta no objeto, fazendo tudo ficar muito real.

A ideia de Jeff Lierberman é aproveitar a iluminação e movimentação dos objetos para criar uma ilusão de óptica impressionante.  O projeto foi inspirado no Slow Dance Frame, um projeto semelhante, mas que exige equipamentos mais complexos e refinados.

• Jogue Flappy Bird com Arduino
• Top 5 Tutoriais com Arduino

Esse projeto interessante não precisa ficar ligado a todo momento, pois ele possui quatro modos de funcionamento. Ele alterna as luzes, fazendo com que os motores liguem e desliguem para realizar o efeito. É realmente uma obra de arte.

Você já é um maker avançado? Que tal replicar este projeto? Está iniciando? Não tem problema, navegue pelo nosso blog e aprenda tudo que você precisa saber para desenvolver projetos fantásticos.

Conhece algum projeto interessante? Conta aqui para gente

Site: Blog FILIPEFLOP