Kit Inicial Completo Arduino & Intel Edison com Sensores, Webcam e Acessórios Essenciais

Componentes e Materiais

Arduino 101		1
Intel Edison		1
Webcam Logitech c270 HD		1
Pololu Carrier com Sensor de Distância Digital Sharp GP2Y0D815Z0F 15cm		2
Resistor Sensível à Força Quadrado Adafruit (FSR) - Interlink 406		1
Placa Breakout Sensor Temperatura e Umidade Adafruit Si7021		1
Seeed Grove Start Kit Plus, Edição Intel IoT		1
Capacitor 47 µF		2
Resistor 1k ohm		1
Bloco Terminal Adafruit - 2 pinos 3.5mm - pacote de 5!		1
Fonte de Alimentação Chaveada Compacta Adafruit - Saída Selecionável 3-12VDC		1
PCB Protoboard Perma-Proto Quarter-sized Adafruit - Unitário		1
Jumpers (genéricos)		1

Ferramentas Necessárias

• Impressora 3D (genérica)
• Ferro de Solda (genérico)

Aplicativos e Serviços Online

• Intel XDK para IoT
• Autodesk Fusion 360
• PubNub Publish/Subscribe API
• Cloudinary
• noble.js

Sobre o Projeto

"É Para os Pássaros!" Reinventando o Futuro do Eco-monitoramento com Arduino 101

Introdução e Motivação

Uma forma de medir a saúde do nosso clima e do ecossistema em que vivemos é medindo o tamanho e a variedade de sua fauna ou população animal. Todo inverno, desde 1987, o Cornell Lab of Ornithology conduz um enorme esforço de ciência cidadã chamado Project FeederWatch:

"Project FeederWatch é uma pesquisa de inverno de pássaros que visitam comedouros em quintais, centros de natureza, áreas comunitárias e outros locais na América do Norte... Dados do FeederWatch mostram quais espécies de pássaros visitam comedouros em milhares de locais pelo continente todo inverno. Os dados também indicam quantos indivíduos de cada espécie são vistos. Esta informação pode ser usada para medir mudanças nas áreas de inverno e abundâncias de espécies de pássaros ao longo do tempo."

Este é nosso primeiro ano participando e queríamos combinar nosso interesse em fazer e hackear, com nosso interesse na natureza e nossa participação no Project FeederWatch. Então decidimos reinventar nosso futuro de observação de pássaros e monitoramento ambiental com o Arduino 101!

O Arduino 101 é ideal para este projeto porque combina a simplicidade da Arduino IDE para tornar nossa programação embarcada fácil, capacidades embarcadas como Bluetooth LE com uma riqueza de sensores e placas breakout prontamente disponíveis. Ao embutir um Arduino 101 em um comedouro caseiro, desenvolvemos uma plataforma experimental para medir parâmetros climáticos e monitorar atividade de pássaros em nosso comedouro. Adicionar algumas tecnologias IoT empolgantes da Cloudinary e PubNub nos ajudou a reinventar o futuro do monitoramento de saúde ambiental e de ecossistemas!

Visão Geral do Projeto

O coração do nosso projeto é um Arduino 101 embutido em um comedouro caseiro. Usamos 2 sensores de distância infravermelho Sharp para detectar pássaros pousados em um pino de madeira passando pelos dois lados do comedouro. Um resistor sensível à força (FSR) é usado para detectar a quantidade de sementes presente no comedouro. Uma placa breakout Adafruit Si7021 de sensor de temperatura e umidade é anexada aos pinos i2c e usada para fornecer nossos dados climáticos físicos. O Arduino 101 é configurado para atuar como dispositivo periférico BLE e enviar dados destes sensores via BLE para um dispositivo central BLE. A alimentação é fornecida por 4 pilhas AA. Todos estes componentes são alojados em um gabinete personalizado impresso em 3D.

Usamos um Intel Edison na Arduino Breakout Board tanto como central BLE quanto como gateway de internet. Uma webcam USB Logitech c270 é conectada à porta USB na placa e usada para tirar fotos quando uma notificação BLE é recebida indicando atividade em um dos poleiros. Estas imagens são armazenadas localmente em um cartão SD inserido no slot de cartão SD na breakout board.

Aproveitamos a capacidade WiFi do Intel Edison para usá-lo como gateway de internet. Isso nos permite usar super tecnologias como PubNub para streaming de dados em tempo real e Cloudinary para armazenamento e manipulação de imagens na nuvem.

O comedouro é feito de uma garrafa de refrigerante vazia e um pino de madeira e pendurado em um poste no nosso quintal.

Construindo o Projeto

Arduino 101 o comedouro embarcado.

A base deste projeto é um Arduino 101 embutido em nosso comedouro. O comedouro ficará ao ar livre e precisará suportar os rigores físicos de estar ao ar livre. Precisará de uma forma de transmitir dados em tempo real e sem fio. A distância entre o Arduino 101 transmissor e o Edison receptor é de apenas alguns pés e como o Arduino 101 já tem BLE embarcado, usaremos BLE!

A maior parte do circuito pode ser construída seguindo o diagrama Fritzing, mas houve alguns desafios que encontramos ao fazer e testar este circuito. São neles que nos concentraremos aqui:

• Primeiro desafio: Detectar um pássaro no comedouro, ao ar livre! Para este projeto precisamos de um sensor que funcione ao ar livre, vedado contra os elementos. Não queremos que perturbe ou espante o alvo. Deve detectar apenas o que está no poleiro. Após avaliar características de vários sensores, decidimos usar o Pololu Carrier com Sensor de Distância Digital Sharp GP2Y0D815Z0F. Estes sensores, diferentemente dos sensores PIR regulares, têm alcance de detecção muito curto. Só queremos saber se um pássaro está pousado a poucos centímetros do sensor. Sensores PIR têm alcance de detecção muito longo e amplo. Isso é ótimo para detectar qualquer tipo de movimento na entrada da sua casa, mas não queremos detectar galhos de árvores ou outros "ruídos" toda vez que o comedouro balança na brisa. Também uma avaliação rápida de bancada mostrou que os sensores IR Sharp funcionavam quando colocados dentro de uma garrafa plástica de refrigerante. Isso é importante porque precisamos proteger a eletrônica dos elementos e ser capazes de "ver através" desta parte do gabinete.

• Segundo desafio: Após conectar um dos sensores e testá-lo, estávamos prontos! Então conectamos um segundo sensor Sharp IR ao Arduino 101 e... eles não funcionaram! Após verificar o código muitas vezes. Após verificar algumas placas e sensores diferentes, nada fazia esses dois sensores funcionarem juntos. Enfrentamos nosso 1º grande desafio. Devemos tentar um tipo diferente de sensor? Devemos fazer um comedouro de poleiro único (sem graça!), o que fazer? Em desespero, fizemos o que deveríamos ter feito da primeira vez, verificamos o site, e nas FAQs do produto encontramos isto: Este sensor não está se comportando como espero: estou obtendo detecção intermitente muito além do alcance máximo do sensor e não está detectando objetos dentro do alcance de detecção anunciado. O que há de errado?Problemas como este podem ser resultado de problemas de fonte de alimentação, especialmente já que este sensor consome energia em rajadas curtas e grandes, então certifique-se de que sua fonte de alimentação é capaz de fornecer a corrente necessária. Se você experimentar este problema, tente adicionar um capacitor de 10 µF ou mais entre alimentação e terra do sensor perto do sensor; isso compensa uma fonte de alimentação inadequada e tipicamente restaura a funcionalidade normal. Problema resolvido! Adicionamos um capacitor eletrolítico de 47uF a cada um dos sensores e eles funcionaram, com apenas mais uma ressalva: ambos precisavam ser alimentados diretamente do pino +5V na placa. Você verá isso no diagrama Fritzing como um jumper da linha +5V de um sensor para a alimentação +5V do outro sensor. Não somos EEs, então não posso explicar, é apenas o que encontramos para funcionar tanto em ambientes internos quanto externos!

• Terceiro desafio: Na seção Atividades Relacionadas e Aprendizado do site Project FeederWatch, uma das atividades recomendadas é pesar a semente de pássaros no comedouro antes e depois de cada contagem e calcular quanta semente foi comida. Após várias contagens, calcular taxa média de consumo. Em vez de realizar pesos manuais, por que não capturar consumo de semente de forma automatizada? Nossa solução foi usar um resistor sensível à força (FSR). Este é um resistor com resistência que varia com a força aplicada. Pode ser conectado a um pino de entrada analógica. Mas seria sensível o suficiente para detectar mudanças nas quantidades de semente? Nossas primeiras tentativas de medir níveis de semente em um pequeno recipiente plástico não foram muito bem-sucedidas. O sensor respondia bem à pressão variável do dedo, mas não aos níveis de semente. Então fizemos duas mudanças para resolver o problema. Primeiro, o sinal analógico é entregue ao pino analógico do Arduino 101 através de um divisor de tensão de 2 resistores, um sendo o FSR e o segundo um resistor convencional. Baixamos o valor deste segundo resistor e o sensor pareceu mais sensível ao toque, mas ainda não era tão responsivo a mudanças de semente quanto gostaríamos. Então adicionamos uma mudança de hardware a tudo isso. Algo por analogia ao princípio de Pascal, que se em vez de aplicar o peso das sementes sobre toda a superfície do FSR, criássemos uma plataforma com um pequeno ponto de contato no centro, aumentaríamos muito a força da semente no FSR. Justo o oposto de uma raquete de neve e funcionou!

Um outro desafio menor é conectar o FSR ao Arduino 101 de forma segura e confiável. Isso é facilmente resolvido pelo uso de blocos de terminal 2 pinos 3.5mm. Apenas certifique-se que o espaçamento do bloco terminal corresponda ao da sua placa.

O resto do hardware do Arduino 101 é simples. Conectamos a placa breakout Adafruit Si702 aos pinos do barramento I2C() e usamos o +3.3V vazio para alimentação. A alimentação de todo o pacote é fornecida através de um pacote de bateria 4xAA com chave alojado sob o gabinete principal.

Soldamos os sensores IR e FSR em PCBs Adafruit Perma-Proto Quarter-sized Breadboard e os fixamos na parte inferior do Arduino 101 com fita dupla face. O pacote inteiro é colocado dentro do comedouro de garrafa de refrigerante e sobreviveu a temperaturas abaixo de zero, neblina, chuva leve e neve (falso nevasca 'Stella'!).

Sketch Arduino 101:

O trabalho principal do sketch é monitorar os sensores anexados e reportar os valores dos sensores via BLE. Todos os dados no BLE são transmitidos como um pacote de bytes. Sejam seus dados originais int, float ou array de char, você terá que quebrá-los em sua representação em bytes para transmitir via BLE. A maneira mais fácil que conheço de fazer isso é criar uma união de tipos de dados. Uma união permite compartilhar a mesma localização de memória entre dois tipos de dados diferentes. No nosso caso, o sensor de temperatura e umidade SI7021 fornece dados como número de ponto flutuante. A linguagem C do Arduino representa um float como 4 bytes, então criamos uma união entre nosso float de temperatura e float de umidade e um array de 4 bytes.

/**
 * A diretiva union permite que estas variáveis compartilhem a mesma localização de memória. Veja o
 * meu tutorial Imu to You!(https://www.hackster.io/gov/imu-to-you-ae53e1?team=18045) para mais
 * discussão sobre o uso da diretiva union em C.
 */
union { float t; unsigned char bytes[4]; } tempData;
union { float h; unsigned char bytes[4]; } humidityData;
union { int f; unsigned char bytes[2]; } feedData;

Quando armazenamos o valor de ponto flutuante na união, o array de bytes também é populado. Para transmitir os dados, passamos o array de bytes para a função setValue() destas características.

Para aplicações embarcadas, o uso de funções delay() pode causar problemas. Primeiro, enquanto a função delay é chamada, toda atividade do processador para pelo período do delay. Isso não é ideal quando pássaros podem vir pousar a qualquer momento. Um segundo problema é que a função delay() pode causar problemas com o mecanismo de notificação BLE. A forma de evitar isso é não usar delay() no nosso sketch. Há, no entanto, muitas vezes em que um atraso no código do programa será necessário. Para superar isso, usaremos o método descrito neste conjunto de 3 super tutoriais de Bill Earl da Adafruit.

Em resumo, criamos um objeto representando nosso dispositivo embarcado. Decidimos um intervalo ou conjunto de intervalos para consultar nossos sensores conectados a este dispositivo. Criamos então uma função Update().

void Update() {
 // Serial.print("Feed Sensor: ");Serial.println(analogRead(A0));
 // Atualizações/notificações de Atividade no Poleiro dependem de tempo e sensores de proximidade
 currentPerchMillis = millis();
 if ((currentPerchMillis - previousPerchMillis) > perchInterval ) {
 previousPerchMillis = currentPerchMillis;
 currentLeftPerch = digitalRead(LEFT_PERCH);
 currentRightPerch = digitalRead(RIGHT_PERCH);
 if ((currentLeftPerch == 0) && (previousLeftPerch == 1)) {
 // nova atividade no poleiro esquerdo
 // BLE notify perchCharacteristic.setValue(1);
 Serial.println("LEFT PERCH ACTIVITY");
 previousLeftPerch = 0;
 }
 ...
 }

Esta função serve para verificar se os intervalos de tempo para nossos sensores passaram, se sim, atualiza os sensores, se não, apenas os ignora. A função Update() é chamada repetidamente na seção loop() do nosso sketch.

void loop() {
 // put your main code here, to run repeatedly:
 blePeripheral.poll();
 birdFeeder.Update();
}

Assim emulamos um efeito multitarefa em tempo real com nossos sensores.

Intel Edison e Arduino Breakout Board:

A parte mais desafiadora de trabalhar com o Intel Edison é configurá-lo. O melhor tutorial que encontrei sobre isso é Intel Edison e Intel XDK IoT Edition 101 de Vincent Wong. Garanto que passar por este processo e tentar alguns dos exemplos JavaScript vale muito a pena!

Trabalhar com seu Edison usando o Intel XDK IoT edition permitirá interagir e configurá-lo na linha de comando. Você também poderá aproveitar os muitos programas de exemplo e templates JavaScript/Node. Aprender e usar JavaScript/Node para programar abrirá um grande número de APIs fáceis de usar e poderosas, como PubNub, Noble.js e Cloudinary.

Uma vez configurado o Edison e confirmada uma conexão ativa à sua rede WiFi, você pode instalar as bibliotecas necessárias para este projeto:

npm install noble

npm install pubnub

npm install cloudinary

A Webcam USB

Uma busca no Google por "intel edison webcam" renderá vários bons exemplos e tutoriais. Mas há material confuso por aí, que acredito ser principalmente devido a mudanças nos módulos disponíveis no Yocto OS. Yocto é uma versão embarcada do Linux que roda no Intel Edison. A Logitech c270 é uma webcam compatível com uvcvideo. Há vários tutoriais sobre como garantir que seu Edison tenha o driver/módulo uvcvideo instalado. Sem isso, você não conseguirá interagir e tirar fotos com a câmera.

Usei os seguintes passos de "Web camera on Intel Edison with uploads to s3" para fazer a webcam funcionar no meu Edison. Postei as instruções deste post abaixo para o caso de alguma vez ficar desatualizado.

Com seu Edison, as seguintes instruções serão executadas na linha de comando na aba terminal serial do XDK.

"Usaremos alguns pacotes adicionais, possíveis de instalar usando o gerenciador de pacotes opkg. Para começar, edite a lista de repos com vi:

vi /etc/opkg/base-feeds.conf

e certifique-se que você tem todas estas linhas no arquivo:

src/gz all https://repo.opkg.net/edison/repo/all src/gz edison https://repo.opkg.net/edison/repo/edison src/gz core2–32 https://repo.opkg.net/edison/repo/core2-32 src intel-iotdk https://iotdk.intel.com/repos/3.0/intelgalactic/opkg/i586

Agora, atualize o cache de pacotes:

opkg update

E instale o módulo do kernel para suportar câmeras usb uvc.

opkg install kernel-module-uvcvideo

Agora conecte sua webcam à porta usb e execute este comando.

ls -l /dev/video*

Se sua câmera for detectada com sucesso, a saída será como:

crw-rw---- 1 root video 81, 0 Jul 25 09:35 /dev/video0

Para trabalhar com webcam e fazer fotos em agendamento, temos que instalar 2 pacotes adicionais:

opkg install fswebcam cronie

*** nota: não instalamos cronie para este projeto, apenas fizemos opkg install fswebcam. cronie não é necessário pois chamamos fswebcam sempre que os sensores IR são acionados por um pássaro no poleiro, não em agendamento temporizado ***

Trabalhando com câmera

Para testar sua câmera, execute este comando:

fswebcam -r 1280x720 --jpeg 100 -D 3 -S 13 "test.jpg"

• -r 1280x720 define resolução da imagem, melhor usar máximo disponível para sua câmera (opcional)
• — jpeg 100 define qualidade JPEG para máximo. Útil se for fazer algo com estas imagens depois (opcional)
• -D 3 -S 13 adiciona 3 segundos de atraso e pula primeiros 13 frames. Necessário, porque algumas webcams precisam de tempo para melhores fotos (recomendado)
• test.jpg é o nome do arquivo de saída

Informações adicionais sobre uso de webcam com Edison, e outros projetos legais, podem ser encontradas na página GitHub da Dra. Kim. Ela também posta projetos legais no Hackster.io!

Além de confirmar que o módulo adequado estava presente, também precisei virar a chave entre os cabos microusb e a porta USB na direção da porta USB e conectar o shield Arduino a uma fonte de alimentação. Usei a Fonte de Alimentação Chaveada Compacta - Saída Selecionável 3-12VDC (produto Adafruit id: 1448).

Agora coloque seu cartão SD no slot de cartão SD. Usando o Terminal Serial no Intel XDK, use a linha de comando para verificar o cartão digitando:

cd /media/sdcard

ls

Isso deve exibir quaisquer arquivos presentes no cartão, ou nada se não houver arquivos. Você não deve ver mensagens de erro. Se vir mensagens de erro, recomendo reiniciar a placa Edison sem remover o cartão SD digitando:

reboot

Então repita os comandos acima após logar novamente no seu Edison.

Agora, para permitir que nosso Edison acesse Bluetooth, digite o seguinte comando:

rfkill unblock bluetooth

Para confirmar que bluetooth está ligado e funcionando, digite:

bluetoothctl

Então digite

scan on

Isso deve mostrar dispositivos BLE próximos como:

Agora saia do bluetoothctl, e clique na aba IoT do Intel XDK então conecte à sua placa. Selecione um projeto no menu lateral esquerdo, como BLESCAN. Remova o conteúdo do index.js e remova as dependências do arquivo package.json.

Substitua o conteúdo do index.js com o programa do nosso repositório GitHub aqui. Carregue este código no seu Edison. Certifique-se que o Arduino 101 está ligado e execute o código do Edison. Uma vez que o Edison detectou seu Arduino 101, você deve ver algo como isto:

O Código

O código rodando no Edison é escrito em JavaScript ou mais propriamente Node.js. Após criar os objetos necessários de nossas bibliotecas importadas, criaremos variáveis para representar o serviço BLE rodando no Arduino 101.

noble.js

// BLE Service and Characteristics for noble
// These should correspond to the peripheral's service and characteristic UUIDs
// (on the Arduino 101 in this case)
var LOCAL_NAME = 'bird';
var SERVICE_UUID = '917649a0d98e11e59eec0002a5d5c51b'; //no dashes!!!!
var PERCH_UUID = '917649a1d98e11e59eec0002a5d5c51b';
var TEMPERATURE_UUID = '917649a2d98e11e59eec0002a5d5c51b';
var HUMIDITY_UUID = '917649a3d98e11e59eec0002a5d5c51b';
var FEED_UUID = '917649a4d98e11e59eec0002a5d5c51b';

Estes UUIDs serão usados pelo noble.js. Se você mudar os UUIDs no seu Arduino, devem ser mudados aqui também. É importante garantir que não tenha traços para o noble.js funcionar corretamente.

Para trabalhar com noble.js, teremos que escanear dispositivos BLE periféricos e então descobri-los e conectar. Uma vez conectados, percorreremos as características disponíveis para usar, usando os UUIDs definidos acima. As características são todas de leitura/notificação.

noble.on('discover', function(peripheral){
 console.log('Found BLE Device: [' + peripheral.id + '] ' + peripheral.advertisement.localName);
 if(peripheral.advertisement.localName == LOCAL_NAME){
 console.log('Found: ' + peripheral.advertisement.localName);
 }
 peripheral.connect(function(error) {
 console.log('Connected to peripheral: ' + peripheral.uuid);
 noble.stopScanning(); // prevent us from picking up "stray" services
 peripheral.discoverServices([SERVICE_UUID], function(error, services) {
 console.log('services: ' + services.length);
 var feederService = services[0];
 console.log('Bird Feeder Service!');
 feederService.discoverCharacteristics([], function(error, characteristics) {
 characteristics.forEach(function(characteristic) {
 console.log('characteristic UUID: ' + characteristic.uuid);
 characteristic.on('data', function(data, isNotification) {
 transformRawData(characteristic.uuid,data);
 });
 characteristic.notify('true', function(error) {
 if (error) throw error;
 });
 });
 });
 });
 });
});

Há 2 elementos-chave a apontar da seção de código acima. Primeiro, houve uma mudança em como você diz ao noble.js que esta é uma característica de leitura/notificação. Da página GitHub de Sandeep Mistry:

Data

Emitido quando leitura de característica foi completada, resultado de characteristic.read(...) ou valor de característica foi atualizado pelo periférico via notificação ou indicação - após ter sido habilitado com notify(true[, callback(error)]).

characteristic.on('data', callback(data, isNotification));

characteristic.once('read', callback(data, isNotification)); // legacy

A mudança é de 'read' para 'data'. Encontramos alguns problemas aqui inadvertidamente usando uma versão mais antiga do noble e depois mudando para a versão mais nova. Levou muitas horas para descobrir o que aconteceu, então queríamos potencialmente ajudar você a evitar isso.

O outro ponto-chave é a função transformRawData(characteristic.uuid,data). Esta função pega o uuid e dados entregues da leitura e passa para a grande e desajeitada função. Cada vez que o mecanismo de notificação BLE é ativado por uma mudança em uma característica, esta função é chamada e lida com os dados recebidos. É onde toda a emoção ocorre.

transformRawData verifica qual característica foi recebida.

No caso do Arduino nos dizer que há atividade no poleiro, queremos tirar uma foto. Neste caso, usamos a biblioteca child_process para fazer uma chamada ao programa fswebcam que reside em nosso sistema Yocto(linux). A biblioteca child_process nos permite executar funções de linha de comando de dentro do nosso código node.js. Este é um recurso muito poderoso.

childProcess.execFile('fswebcam',['-r 1280x720',fileName],function(error,stdout,stderr) {
 console.log(stdout);
});

PubNub e Cloudinary:

Esta função também é onde PubNub e Cloudinary entram em ação! PubNub fornece uma rede de streaming de dados em tempo real para sua aplicação. O que isso significa é que com uma conexão de internet sua aplicação pode fazer streaming de dados ao vivo para qualquer lugar no mundo. Qualquer outro app ou programa que tenha a chave de assinatura para seus streams publicados terá acesso a um payload JSON representando seus dados. No nosso caso, enviamos nível atual de semente, temperatura, umidade e contagens de visitas aos poleiros. Além disso, enviamos um link para as 3 fotos mais recentes do comedouro! Estes são jpegs que foram carregados para Cloudinary com nosso programa. Não há necessidade de rodar um servidor! Um simples arquivo HTML com JavaScript embutido serve como interface em tempo real para nosso comedouro cortesia do PubNub!

Na imagem acima, simplesmente enviei por e-mail para mim mesmo o arquivo HTML contendo o código para interfacear com o comedouro via PubNub e carreguei cada um de um diretório local no navegador Chrome. Não há necessidade de você codificar um servidor para servir esta página no seu Edison.

Cloudinary é um serviço de upload, armazenamento e transformação de imagens. Tem uma API muito simples de usar. No desenvolvimento deste projeto, não encontrei API mais fácil e direta de usar. Não há nada comparável por aí. O suporte deles é fantástico também. Definitivamente algo que você vai querer conferir para seus projetos!

No código abaixo usamos a API cloudinary para carregar as 3 imagens mais recentes do cartão SD local. As URLs retornadas deste upload são então salvas em um array. Estas URLs são então enviadas como parte do nosso payload JSON para PubNub para que possam ser acessadas pela nossa página HTML para exibir. Beleza, hein?!

index.html

O que é este arquivo index.html? O arquivo index.html é nossa UI. Como estamos fazendo streaming de nossos dados usando PubNub e colocando nossas imagens em uma URL publicamente acessível com Cloudinary, podemos aproveitar o trio de poder JavaScript/HTML/CSS para criar uma UI portátil. Tanto PubNub quanto Cloudinary têm APIs JavaScript muito fáceis de usar e poderosas. Simplesmente as importamos em nosso arquivo html para usá-las:

<script src="https://cdn.pubnub.com/sdk/javascript/pubnub.4.5.0.js"></script>
<script type="text/javascript" src="https://pubnub.github.io/eon/v/eon/1.0.0/eon.js"></script>
<link type="text/css" rel="stylesheet" href="https://pubnub.github.io/eon/v/eon/1.0.0/eon.css" />

Ao criar o objeto PubNub, damos a ele a chave de assinatura do nosso stream de dados e ele pode acessar o stream em tempo real sempre que estamos publicando este stream.

<script type="text/javascript">
var pubnub = new PubNub({
 subscribeKey : "sua chave de assinatura vai aqui",
});

Após se inscrever no PubNub, passe por alguns tutoriais e aprenda como obter suas chaves pub e sub.

Não precisamos instanciar um objeto Cloudinary neste código para exibir as 3 imagens mais recentes na UI. Nosso stream PubNub envia as URLs destas imagens no payload JSON. Simplesmente assinamos o canal, 'feederview' no nosso stream "decodificamos" o payload e atualizamos e exibimos as imagens:

// assina o canal feederview aqui
pubnub.subscribe({channels: ['feederView']});
// decodifica o payload JSON sempre que novas imagens chegam
pubnub.addListener({
 message: function(m){
 var msg = m.message; var chan = m.channel;
 var theURLMSG = JSON.parse(JSON.stringify(msg));
 console.log("This is it: " + theURLMSG["latestView"]);
 console.log("The image index: " + theURLMSG["imageIndex"]);
 var imageIndex = theURLMSG["imageIndex"];
 if (theURLMSG.latestView != null) {
 if (imageIndex=="0"){ document.getElementById("myImage0").src=theURLMSG["latestView"]; }
 else if (imageIndex=="1") { document.getElementById("myImage1").src=theURLMSG["latestView"]; }
 else if (imageIndex=="2") { document.getElementById("myImage2").src=theURLMSG["latestView"]; }
 }
 }
});

PubNub tem uma biblioteca especial para facilitar exibição gráfica de dados. Chama-se eon.js. É fácil de usar e há muitos bons tutoriais e um excelente webinar sobre seu uso. Recomendo passar por estes para entender como criamos nossos widgets de exibição de dados.

Comedouro e Gabinete

Construir o comedouro é bem fácil. Para a construção do comedouro, comecei cortando uma linha perfeitamente reta em uma garrafa de refrigerante de 2 litros cerca de 11 cm de altura usando um estilete. Então cortei buracos cerca de 3 cm de altura na peça inferior onde deslizei um pino de madeira que atuaria como poleiro. Então coloquei o pacote eletrônico dentro, para testar o tamanho, e foi um ajuste apertado. Para a parte superior, comecei furando pequenos buracos logo abaixo da tampa da garrafa e inserindo um fio metálico cerca de 30 cm de comprimento e dei um nó no topo. Então cortei quatro buracos em cada lado, todos em alturas diferentes para caber pássaros de diferentes tamanhos, e para deixar o cheiro da semente sair para atrair mais pássaros. Finalmente, deslizei a parte superior na inferior e prendi com fita adesiva, certificando que a fita não cobrisse os sensores. Embora eu tenha escolhido usar fita adesiva, fita de embalagem transparente também funcionaria. Quando tudo estava seguro e pronto, enchi a semente usando um funil e coloquei lá fora e esperei os pássaros virem.

Para o gabinete do comedouro tipo garrafa, primeiro medi o diâmetro da garrafa pegando o rótulo, achando o comprimento (a circunferência) e dividindo por pi. A garrafa resultou em cerca de 105mm de diâmetro e baseei todo o pacote neste número. Comecei fazendo um gabinete que pudesse segurar o arduino e as duas protoboards, e uma tampa que tivesse uma alça para facilitar puxar o pacote para fora. Também fiz um pequeno gabinete na parte inferior que pudesse segurar o pacote de baterias, e o projetei de forma que consegui economizar metade do filamento que poderia ter usado de outra forma. Decidimos ir ainda mais longe com o sensor de pressão então criei uma tampa que também economizasse filamento mantendo a mesma rigidez.

Finalmente, imprimi a placa que ajudaria o sensor de pressão e aparafusei todas as peças juntas. O resultado foi um pacote compacto que funcionou muito bem:

Testando

Testamos o comedouro antes da implantação. Há várias áreas críticas de funcionalidade neste projeto e testamos sistematicamente antes da nossa implantação.

Primeiro confirmamos conectividade BLE em 2 partes. Primeiro, confirmamos o funcionamento adequado do Arduino 101 para enviar notificações via BLE usando o app nRF Master Control. Encontrei esta ferramenta confiável e indispensável para depurar meus projetos BLE. Em seguida, confirmamos que poderíamos receber sinais de fora da casa bem além do alcance que pretendíamos colocar o comedouro. Uma vez que o Edison estava pronto, reconfirmamos isso. Usar esta abordagem nos permitiu focar em uma coisa de cada vez. Embora não seja um projeto ultra complexo, tem peças suficientes para causar confusão se você não fizer passo a passo. Uma coisa que descobrimos foi que quando as baterias ficavam fracas, a primeira função a ser perdida era o BLE.

Também fizemos alguma calibração do nosso FSR e achamos resultados interessantes. Com nossa plataforma de ponto de contato encontramos uma faixa linear, dentro de uma resposta não-linear geral à adição de semente:

Por enquanto, apenas usamos estes valores para ajustar nossas faixas min/max e cores no gauge Eon.js do comedouro, mas exploraremos isso no futuro para podermos estimar alimentação com precisão.

Galeria de Implantação

A melhor parte deste projeto tem que ser revisar as fotos! Você pode fazer isso online no painel Cloudinary ou olhando os arquivos armazenados no cartão SD. Uma vez que os pássaros descobrem seu comedouro, você pode facilmente gerar 2.000 jpegs em poucas horas! Isso não é exagero!

Nota sobre alinhamento com Project FeederWatch.

Veja O Que o Futuro Trará!

Já começamos a redesenhar e testar nosso circuito usando o kit SeeedStudio. Não entramos no concurso a tempo para qualificar para o hardware grátis, mas compramos um Grove Starter Kit por conta própria. Muito importante: a fonte de alimentação do Base Shield nos permite usar ambos sensores IR Sharp SEM os capacitores de suporte! Ambos sensores funcionam muito bem com eles. Um benefício adicional, como você pode ver na foto abaixo, é o layout muito simplificado. Isso é para um comedouro e não um ninho de pássaros! Provavelmente deveríamos ter começado nossa prototipagem com o kit Grove SeeedStudio!

O sensor infravermelho padrão da Seeed não era o mesmo dos sensores IR Sharp que usamos, então modificamos ligeiramente nossos sensores para serem compatíveis com o base shield. Simplesmente soldando fio de núcleo sólido nas linhas GND, Vin e SIG do sensor IR, conseguimos conectar:

Alinhamento com Project FeederWatch e Conclusão

Nossa inspiração original para este projeto foi entrar no Project FeederWatch pela primeira vez. Então como nosso comedouro IoT se alinha com os objetivos e método de medição do Project FeederWatch?

Project FeederWatch tem metodologia específica e validada para sua contagem de pássaros. Ao longo de 2 dias consecutivos, você reporta o número máximo de pássaros de um certo tipo vistos em um ponto no tempo. Então nossas contagens de poleiro não combinam realmente com isso. No entanto, medir parâmetros ambientais e automatizar nosso consumo de semente definitivamente sim. Também tirar fotos dos pássaros visitando nosso comedouro nos ajuda a aprender identificações. Também, se um pássaro "raro" visitasse, teríamos a documentação fotográfica necessária para documentar esta visita.

O potencial de streaming ao vivo dos dados via rede PubNub é enorme. Dados e imagens poderiam ser compartilhados entre observadores de pássaros e salas de aula ao redor do mundo, ao vivo e em tempo real! Uma área que gostaríamos de explorar é o bloco clarifai no PubNub. Poderíamos enviar a imagem armazenada no cloudinary para clarifai para adicionar detecção de pássaros e tipos de pássaros em nossas imagens? Poderíamos usar o bloco PubNub cloudinary para ajudar a corrigir qualidade de imagem ruim devido a condições climáticas variáveis? Quais outros sensores Seeed/Grove poderíamos adicionar?

Como makers geeks, este projeto também foi muito divertido. Realmente gostamos de assistir os pássaros ao vivo no comedouro e depois voltar para ver que tipo de fotos capturamos foi como uma mini caça ao tesouro! Ver os dados de alimentação diminuírem ao longo do dia, enquanto literalmente coletávamos milhares de jpegs foi super divertido. E usar arduinos, edisons e melhorar com Grove e usar as tecnologias web de PubNub e Cloudinary para tudo funcionar junto foi um grande desafio para nós. . . oh yeah e mencionamos a impressão 3D?

Esperamos que você se inspire a se inscrever no FeederWatch e concorde conosco que no final . . . É Para os Pássaros!

Código

É Para os Pássaros!

Todos os arquivos de código necessários para este projeto estão postados aqui: https://github.com/lachendeKatze/ItsForTheBirds

Peças Personalizadas e Gabinetes

Arquivos .stl para nosso projeto

Estes são os arquivos stl essenciais para construir seu comedouro "em garrafa de refrigerante": https://github.com/lachendeKatze/ItsForTheBirds/tree/master/3DBuild

Esquemáticos

Este é o circuito embutido no Comedouro

A parte do circuito do Edison é simples e não encontramos um componente Fritzing adequado para a webcam, então apenas tiramos uma foto dele.