"¡Es Por Los Pájaros!" Reinventando el Monitoreo Ecológico con Arduino 101 e Intel Edison

Componentes y Suministros

Componente	Descripción	Cantidad
Arduino 101		1
Intel Edison		1
Webcam Logitech c270 HD		1
Sensor de Distancia Digital Sharp GP2Y0D815Z0F 15cm (Pololu Carrier)		2
Resistente Sensible a la Fuerza (FSR) Adafruit Square - Interlink 406		1
Sensor Temperatura/Humedad Adafruit Si7021 Breakout		1
Seeed Grove Starter Kit Plus, Intel IoT Edition		1
Condensador 47 µF		2
Resistencia 1k Ω		1
Bloque Terminal Adafruit 2-pin 3.5mm (pack 5)		1
Fuente Conmutada Compacta Adafruit 3-12VDC Seleccionable		1
PCB Perma-Proto Quarter-sized Adafruit		1
Cables puente (genéricos)		1

Herramientas Necesarias

• Impresora 3D (genérica)
• Soldador (genérico)

Aplicaciones y Servicios Online

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

Sobre este Proyecto

Introducción y Motivación

Una forma de medir la salud de nuestro clima y el ecosistema en el que vivimos es midiendo el tamaño y variedad de su fauna o población animal. Cada invierno, desde 1987, el Laboratorio de Ornitología de Cornell realiza un enorme esfuerzo de ciencia ciudadana llamado Project FeederWatch:

"Project FeederWatch es una encuesta de invierno de aves que visitan comederos en patios traseros, centros naturales, áreas comunitarias y otros lugares en Norteamérica... Los datos de FeederWatch muestran qué especies de aves visitan comederos en miles de ubicaciones a través del continente cada invierno. Los datos también indican cuántos individuos de cada especie se ven. Esta información puede usarse para medir cambios en los rangos de invierno y abundancias de especies de aves a lo largo del tiempo."

Este es nuestro primer año participando y quisimos combinar nuestro interés en hacer y hackear, con nuestro interés en la naturaleza y nuestra participación en Project FeederWatch. ¡Así que decidimos reinventar nuestro futuro de observación de aves y monitoreo ambiental con el Arduino 101!

El Arduino 101 es ideal para este proyecto porque combina la simplicidad del Arduino IDE para facilitar nuestra programación embebida, capacidades integradas como Bluetooth LE con una gran cantidad de sensores y placas breakout disponibles. Al embeber un Arduino 101 en un comedero casero, desarrollamos una plataforma experimental para medir parámetros climáticos y monitorear la actividad de aves en nuestro comedero. ¡Agregar algunas tecnologías IoT emocionantes de Cloudinary y PubNub nos ayudó a reinventar el futuro del monitoreo de salud ambiental y de ecosistemas!

Visión General del Proyecto

El corazón de nuestro proyecto es un Arduino 101 embebido en un comedero casero. Usamos 2 sensores de distancia infrarroja Sharp para detectar aves posadas en un listón de madera que atraviesa ambos lados del comedero. Una resistencia sensible a la fuerza (FSR) se usa para detectar la cantidad de semilla presente en el comedero. Una placa breakout Adafruit Si7021 de temperatura y humedad está conectada a los pines I2C y se usa para proporcionar nuestros datos meteorológicos físicos. El Arduino 101 está configurado para actuar como dispositivo periférico BLE y enviar datos de estos sensores por BLE a un dispositivo central BLE. La alimentación la proporcionan 4 pilas AA. Todos estos componentes están alojados en una carcasa personalizada impresa en 3D.

Usamos un Intel Edison en la placa Arduino Breakout Board tanto como dispositivo central BLE como puerta de enlace a internet. Una webcam Logitech c270 USB está conectada al puerto USB de la placa y se usa para tomar fotos cuando se recibe una notificación BLE que indica actividad en uno de los posaderos. Estas imágenes se almacenan localmente en una tarjeta SD insertada en la ranura de la breakout board.

Aprovechamos la capacidad WiFi del Intel Edison para usarlo como puerta de enlace a internet. Esto nos permite usar super tecnologías como PubNub para streaming de datos en tiempo real y Cloudinary para almacenamiento y manipulación de imágenes en la nube.

El comedero está hecho de una botella de refresco vacía y un listón de madera, colgado de un poste en nuestro jardín.

Construyendo el Proyecto

Arduino 101: El Comedero Embebido

La base de este proyecto es un Arduino 101 embebido en nuestro comedero. El comedero estará al aire libre y necesita resistir las inclemencias físicas. Necesita una forma de transmitir datos en tiempo real e inalámbricamente. La distancia entre el Arduino 101 transmisor y el Edison receptor es solo unos pies y como el Arduino 101 ya tiene BLE integrado, ¡usaremos BLE!

La mayor parte del circuito puede construirse siguiendo el diagrama de Fritzing, pero hubo algunos desafíos al hacer y probar este circuito. En ellos nos concentraremos:

Primer Desafío: Detectar un ave en el comedero, ¡al aire libre!

Para este proyecto necesitamos un sensor que funcione al aire libre, sellado contra los elementos. No queremos que moleste o ahuyente al sujeto. Solo debe detectar lo que está en el posadero. Tras evaluar varios sensores, decidimos usar el Pololu Carrier con Sharp GP2Y0D815Z0F Digital Distance Sensor. Estos sensores, a diferencia de los sensores PIR regulares, tienen un rango de detección muy corto. Solo queremos saber si un ave está posada a pocos centímetros del sensor. Los sensores PIR tienen un rango de detección muy largo y amplio. Esto es genial para detectar movimiento en la entrada de tu casa, pero no queremos detectar ramas de árboles u otro "ruido" cada vez que el comedero se balancea con la brisa. También una evaluación rápida en banco mostró que los sensores Sharp IR funcionaban cuando se colocaban dentro de una botella de plástico. ¡Esto es importante porque necesitamos proteger la electrónica de los elementos y poder "ver a través" de esta parte de la carcasa!

Segundo Desafío: Dos Sensores No Funcionan Juntos

Después de conectar un sensor y probarlo, estábamos listos. Conectamos un segundo sensor Sharp IR al Arduino 101 y... ¡no funcionaban! Tras revisar el código muchas veces, probar un par de placas y diferentes sensores, nada hacía que estos dos sensores funcionaran juntos. Nos enfrentamos a nuestro primer gran desafío. ¿Deberíamos probar un tipo de sensor diferente? ¿Hacer un comedero de un solo posadero (aburrido!), qué hacer? En desesperación hicimos lo que deberíamos haber hecho la primera vez: revisar la web, y en las FAQs del producto encontramos esto:

"Este sensor no se comporta como espero: obtengo detección intermitente mucho más allá del rango máximo y no detecta objetos dentro del rango anunciado. ¿Qué pasa?" Problemas como este pueden resultar de problemas de alimentación, especialmente porque este sensor consume energía en ráfagas cortas y grandes, así que asegúrate de que tu fuente de alimentación sea capaz de entregar la corriente necesaria. Si experimentas este problema, intenta agregar un condensador de 10 µF o así entre la alimentación y tierra del sensor cerca del sensor; esto compensa una fuente de alimentación inadecuada y típicamente restaura la funcionalidad normal.

¡Problema resuelto! Agregamos un condensador electrolítico de 47uF a cada sensor y funcionaron, con una sola salvedad: ambos necesitaban alimentarse directamente del pin +5V de la placa. Verás esto en el diagrama de Fritzing como un puente desde la línea +5V de un sensor al suministro +5V del otro. No somos ingenieros electrónicos, así que no puedo explicarlo, ¡es solo lo que encontramos que funciona tanto en interiores como en exteriores!

Tercer Desafío: Medir Consumo de Semilla Automáticamente

En la sección de Actividades Relacionadas y Aprendizaje del sitio web de Project FeederWatch, una de las actividades recomendadas es pesar la semilla en tu comedero antes y después de cada conteo y calcular cuánta semilla se comió. Después de varios conteos, calcular la tasa de consumo promedio. En lugar de hacer pesos manuales, ¿por qué no capturar el consumo de semilla de forma automática? Nuestra solución fue usar una resistencia sensible a la fuerza (FSR). Es una resistencia cuya resistencia varía con la fuerza aplicada. Puede conectarse a un pin de entrada analógica. ¿Pero sería lo suficientemente sensible para detectar cambios en la cantidad de semilla? Nuestros primeros intentos de medir niveles de semilla en un recipiente plástico pequeño no fueron muy exitosos. El sensor respondía bien a la presión variable del dedo, pero no a los niveles de semilla. Hicimos dos cambios para resolver el problema. Primero, la señal analógica se entrega al pin analógico del Arduino 101 a través de un divisor de voltaje de 2 resistencias, una siendo la FSR y la segunda una resistencia convencional. Bajamos el valor de esta segunda resistencia y el sensor pareció más sensible al tacto, pero aún no respondía a los cambios de semilla como queríamos. Así que agregamos un cambio de hardware a todo esto. Algo análogo al principio de Pascal: si en lugar de aplicar el peso de las semillas sobre toda la superficie de la FSR, creamos una plataforma con un pequeño punto de contacto en su centro, aumentaríamos enormemente la fuerza de la semilla sobre la FSR. ¡Justo lo opuesto a una raqueta de nieve y funcionó!

Otro reto menor es conectar la FSR al Arduino 101 de forma segura y confiable. Se soluciona fácilmente usando bloques terminales de 2-pin 3.5mm. Solo asegúrate de que el espaciado del bloque terminal coincida con el de tu placa.

El resto del hardware del Arduino 101 es simple. Conectamos la placa breakout Adafruit Si7021 a los pines del bus I2C y usamos el pin +3.3V vacío para alimentación. La alimentación de todo el paquete se proporciona a través de un paquete de baterías 4xAA con interruptor alojado debajo de la carcasa principal.

Soldamos los sensores IR y FSR a PCBs Adafruit Perma-Proto Quarter-sized y los adherimos a la parte inferior del Arduino 101 con cinta de doble cara. Todo el paquete se coloca dentro de la botella de refresco del comedero y ha sobrevivido temperaturas bajo cero, neblina, lluvia ligera y nieve (¡falso blizzard 'Stella'!).

Sketch del Arduino 101

El trabajo principal del sketch es monitorear los sensores conectados y reportar los valores de los sensores por BLE. Todos los datos en BLE se transmiten como un paquete de bytes. Ya sea que tus datos originales sean int, float o array de char, tendrás que descomponerlos en su representación de bytes para transmitir por BLE. La forma más fácil que conozco de hacer esto es crear una unión (union) de tipos de datos. Una unión nos permite compartir la misma ubicación de memoria entre dos tipos de datos diferentes. En nuestro caso, el sensor de temperatura y humedad SI7021 proporciona datos como número de punto flotante. El lenguaje C de Arduino representa un float como 4 bytes, así que creamos una unión entre nuestro float de temperatura y humedad y un array de 4 bytes.

/** 
 * La directiva union permite que estas variables compartan la misma ubicación de memoria. 
 * Ver mi tutorial Imu to You! para más discusión sobre el uso de union en 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;

Cuando almacenamos el valor de punto flotante en la unión, el array de bytes se popula también. Para transmitir los datos, pasamos el array de bytes a la función setValue() de estas características.

Para aplicaciones embebidas, el uso de funciones delay() puede causar problemas. Primero, mientras se llama a la función delay, toda la actividad del procesador se detiene por el período del delay. Esto no es ideal cuando las aves pueden venir a posarse en cualquier momento. Un segundo problema es que la función delay() puede causar problemas con el mecanismo de notificación BLE. La forma de evitar esto es no usar delay() en nuestro sketch. Sin embargo, hay muchas veces que se necesitará un delay en el código. Para superar esto, usaremos el método descrito en este conjunto de 3 super tutoriales de Bill Earl de Adafruit.

En resumen, creamos un objeto que representa nuestro dispositivo embebido. Decidimos un intervalo o conjunto de intervalos para sondear nuestros sensores conectados a este dispositivo. Luego creamos una función Update().

void Update() {
  // Serial.print("Feed Sensor: "); Serial.println(analogRead(A0));
  // Actualizaciones/notificaciones de actividad en posaderos dependen de tiempo y sensores de proximidad
  currentPerchMillis = millis();
  if ((currentPerchMillis - previousPerchMillis) > perchInterval) {
    previousPerchMillis = currentPerchMillis;
    currentLeftPerch = digitalRead(LEFT_PERCH);
    currentRightPerch = digitalRead(RIGHT_PERCH);
    if ((currentLeftPerch == 0) && (previousLeftPerch == 1)) {
      // nueva actividad en el posadero izquierdo
      // BLE notify
      perchCharacteristic.setValue(1);
      Serial.println("LEFT PERCH ACTIVITY");
      previousLeftPerch = 0;
    }
    // ...
  }
}

Esta función sirve para verificar si los intervalos de tiempo para nuestros sensores han pasado; si es así, actualiza los sensores, si no, los ignora. La función Update() se llama repetidamente en la sección loop() de nuestro sketch.

void loop() {
  blePeripheral.poll();
  birdFeeder.Update();
}

De esta manera emulamos un efecto de multitarea en tiempo real con nuestros sensores.

Intel Edison y Arduino Breakout Board

La parte más desafiante de trabajar con el Intel Edison es configurarlo. El mejor tutorial que he encontrado es "Intel Edison and Intel XDK IoT Edition 101" de Vincent Wong. ¡Puedo garantizar que pasar por este proceso y probar algunos ejemplos de JavaScript vale la pena!

Trabajar con tu Edison usando Intel XDK IoT Edition te permitirá interactuar y configurarlo en la línea de comandos. También podrás aprovechar los muchos programas de ejemplo y plantillas de JavaScript/Node. Aprender y usar JavaScript/Node para programar abrirá un gran número de APIs fáciles de usar y poderosas, como PubNub, Noble.js y Cloudinary.

Una vez que hayas configurado el Edison y confirmado una conexión activa a tu red WiFi, puedes instalar las librerías necesarias para este proyecto:

npm install noble
npm install pubnub
npm install cloudinary

La Webcam USB

Una búsqueda de "intel edison webcam" dará varios buenos ejemplos y tutoriales. Pero hay material confuso, que creo se debe principalmente a cambios en los módulos disponibles en el Yocto OS. Yocto es una versión embebida de Linux que corre en el Intel Edison. La Logitech c270 es una webcam compatible con uvcvideo. Hay numerosos tutoriales sobre cómo asegurar que tu Edison tenga el módulo/driver uvcvideo instalado. Sin esto, no podrás interactuar y tomar fotos con la cámara.

Usé los siguientes pasos de "Web camera on Intel Edison with uploads to s3" para hacer funcionar la webcam en mi Edison. He publicado las instrucciones de este post a continuación por si acaso deja de estar disponible.

Con tu Edison, las siguientes instrucciones se ejecutarán en la línea de comandos en la pestaña Serial Terminal del XDK.

# Editamos la lista de repos con vi:
vi /etc/opkg/base-feeds.conf
# Aseguramos que tengas todas estas líneas:
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

# Actualizamos caché de paquetes:
opkg update

# Instalamos módulo de kernel para soportar cámaras USB uvc:
opkg install kernel-module-uvcvideo

# Conecta tu webcam al puerto USB y ejecuta:
ls -l /dev/video*
# Si tu cámara se detectó correctamente, la salida será como:
# crw-rw---- 1 root video 81, 0 Jul 25 09:35 /dev/video0

# Para trabajar con la webcam y hacer fotos a demanda instalamos 2 paquetes adicionales:
opkg install fswebcam cronie
# *** nota: no instalamos cronie para este proyecto, solo hicimos opkg install fswebcam. 
# cronie no es necesario ya que llamamos a fswebcam cuando los sensores IR son activados por un ave, no en horario programado ***

# Trabajar con la cámara:
# Para probar tu cámara, ejecuta:
fswebcam -r 1280x720 --jpeg 100 -D 3 -S 13 "test.jpg"
# -r 1280x720: resolución de imagen (opcional)
# --jpeg 100: calidad JPEG máxima (opcional)
# -D 3 -S 13: añade 3 seg de delay y salta primeros 13 frames (recomendado)
# test.jpg: nombre del archivo de salida

Información adicional sobre uso de webcam con Edison y otros proyectos geniales, en la página GitHub de la Dra. Kim. También publica proyectos geniales en Hackster.io.

Además de confirmar que el módulo apropiado estaba presente, también necesité cambiar el interruptor entre los cables microusb y el puerto USB hacia la dirección del puerto USB y conectar el shield Arduino a una fuente de alimentación. Usé la Compact Switching Power Supply - Selectable Output 3-12VDC (Adafruit product id: 1448).

Ahora coloca tu tarjeta SD en la ranura. Usando el Serial Terminal en Intel XDK, usa la línea de comandos para verificar la tarjeta:

cd /media/sdcard
ls

Esto debería mostrar cualquier archivo presente en la tarjeta, o nada si no hay archivos. No deberías ver mensajes de error. Si ves errores, recomiendo reiniciar la placa Edison sin quitar la tarjeta SD:

reboot

Luego repite los comandos anteriores después de volver a conectar a tu Edison.

Ahora, para permitir que nuestro Edison acceda a Bluetooth, ejecuta:

rfkill unblock bluetooth

Para confirmar que Bluetooth está encendido y funcionando:

bluetoothctl
scan on

Esto debería mostrar dispositivos BLE cercanos.

Ahora sal de bluetoothctl, y haz clic en la pestaña IoT del Intel XDK y conecta a tu placa. Selecciona un proyecto del menú lateral, como BLESCAN. Vacía el contenido de index.js y elimina las dependencias del archivo package.json.

Reemplaza el contenido de index.js con el programa de nuestro repositorio GitHub. Sube este código a tu Edison. Asegúrate de que el Arduino 101 esté encendido y ejecuta el código del Edison. Una vez que el Edison haya detectado tu Arduino 101 deberías ver algo como esto:

El Código

El código que corre en el Edison está escrito en JavaScript o más propiamente Node.js. Después de crear los objetos necesarios de nuestras librerías importadas, crearemos variables para representar el servicio BLE que corre en el Arduino 101.

noble.js

// BLE Service and Characteristics for noble
// Deben corresponder a los UUIDs de servicio y característica del periférico
// (en el Arduino 101 en este caso)
var LOCAL_NAME = 'bird';
var SERVICE_UUID = '917649a0d98e11e59eec0002a5d5c51b'; // ¡sin guiones!
var PERCH_UUID = '917649a1d98e11e59eec0002a5d5c51b';
var TEMPERATURE_UUID = '917649a2d98e11e59eec0002a5d5c51b';
var HUMIDITY_UUID = '917649a3d98e11e59eec0002a5d5c51b';
var FEED_UUID = '917649a4d98e11e59eec0002a5d5c51b';

Estos UUIDs serán usados por noble.js. Si cambias los UUIDs en tu Arduino, deben cambiarse aquí también. Es importante asegurarse de que no haya guiones para que noble.js funcione correctamente.

Para trabajar con noble.js tendremos que escanear dispositivos periféricos BLE y luego descubrirlos y conectar. Una vez conectados, recorreremos las características disponibles usando los UUIDs definidos arriba. Las características son todas de lectura/notificación.

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(); // evitar captar servicios "perdidos"
    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;
          });
        });
      });
    });
  });
});

Hay 2 elementos clave en el código anterior. Primero, hubo un cambio en cómo le dices a noble.js que esto es una característica de lectura/notificación. De la página GitHub de Sandeep Mistry:

Data

Emitido cuando la lectura de característica se completa, resultado de characteristic.read(...) o el valor de la característica ha sido actualizado por el periférico vía notificación o indicación - después de haber sido habilitado con notify(true[, callback(error)]).

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

El cambio es de 'read' a 'data'. Tuvimos problemas aquí usando inadvertidamente una versión antigua de noble y luego cambiando a la más nueva. Tomó muchas horas averiguar qué pasó, así que queríamos ayudarte a evitar esto.

El otro punto clave es la función transformRawData(characteristic.uuid, data). Esta función toma el uuid y los datos entregados de la lectura y los pasa a la gran y difícil función. Cada vez que el mecanismo de notificación BLE es activado por un cambio en una característica, esta función es llamada y maneja los datos recibidos. ¡Aquí es donde ocurre toda la emoción!

transformRawData verifica qué característica se recibió.

En el caso que el Arduino nos diga que hay actividad en el posadero, queremos tomar una foto. En este caso, usamos la librería child_process para hacer una llamada al programa fswebcam que reside en nuestro sistema Yocto (Linux). La librería child_process nos permite ejecutar funciones de línea de comandos desde nuestro código Node.js. Esta es una característica muy poderosa.

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

PubNub y Cloudinary

¡Esta función también es donde PubNub y Cloudinary entran en juego! PubNub proporciona una red de streaming de datos en tiempo real a tu aplicación. Esto significa que con una conexión a internet tu aplicación puede hacer streaming de datos en vivo a cualquier parte del mundo. Cualquier otra app o programa que tenga la clave de suscripción a tus streams publicados tendrá acceso a un payload JSON representando tus datos. En nuestro caso enviamos el nivel actual de semilla, temperatura, humedad y conteos de visitas a posaderos. Adicionalmente, enviamos un enlace a las 3 fotos más recientes del comedero. Estos son JPEGs que han sido subidos a Cloudinary con nuestro programa. ¡No hay necesidad de correr un servidor! Un simple archivo HTML con JavaScript embebido sirve como interfaz en tiempo real a nuestro comedero cortesía de PubNub.

En la imagen de arriba, simplemente me envié por email el archivo HTML que contiene el código para interfaz con el comedero sobre PubNub y lo cargué cada uno desde un directorio local en un navegador Chrome. No hay necesidad de que codifiques un servidor para servir esta página en tu Edison.

Cloudinary es un servicio de subida, almacenamiento y transformación de imágenes. Tiene una API muy simple de usar. Desarrollando este proyecto, no encontré una API más fácil y directa. Su mesa de ayuda es fantástica también. ¡Definitivamente algo que querrás revisar para tus proyectos!

En el código a continuación usamos la API de Cloudinary para subir las 3 imágenes más recientes desde la tarjeta SD local. Las URLs retornadas de esta subida se guardan en un array. Estas URLs se envían como parte de nuestro payload JSON a PubNub para que puedan ser accedidas por nuestra página HTML para mostrar. ¡Belleza, eh?!

index.html

¿De qué trata este archivo index.html? El archivo index.html es nuestra UI. Como estamos transmitiendo nuestros datos usando PubNub y colocando nuestras imágenes en una URL públicamente accesible con Cloudinary, podemos aprovechar el trío de poder JavaScript/HTML/CSS para crear una UI portable. Tanto PubNub como Cloudinary tienen APIs de JavaScript muy fáciles de usar y poderosas. Simplemente las importamos en nuestro archivo html para usarlas:

<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" />

Al crear el objeto PubNub, le damos la clave de suscripción a nuestro stream de datos y puede acceder al stream en tiempo real siempre que estemos publicando este stream.

<script type="text/javascript">
  var pubnub = new PubNub({
    subscribeKey: "tu clave de suscripción aquí",
  });

Después de registrarte en PubNub, pasa por algunos tutoriales y aprende cómo obtener tus claves pub y sub.

No necesitamos instanciar un objeto Cloudinary en este código para mostrar las 3 imágenes más recientes en la UI. Nuestro stream PubNub envía las URLs de estas imágenes en el payload JSON. Simplemente nos suscribimos al canal 'feederview' en nuestro stream, "decodificamos" el payload y actualizamos y mostramos las imágenes:

// Suscribirse al canal feederview
pubnub.subscribe({channels: ['feederView']});

// Decodificar el payload JSON cuando lleguen nuevas imágenes
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 tiene una librería especial para facilitar la visualización gráfica de datos. Se llama eon.js. Es fácil de usar y hay muchos buenos tutoriales y un excelente webinar sobre su uso. Recomiendo pasar por estos para entender cómo creamos nuestros widgets de visualización de datos.

Comedero y Carcasa

Construir el comedero es bastante fácil. Para la construcción, empecé cortando una línea perfectamente recta en una botella de refresco de 2 litros a unos 11 cm de altura usando un cúter. Luego corté agujeros de unos 3 cm de alto en la pieza inferior donde deslicé un listón de madera que actuaría como posadero. Luego puse el paquete de electrónica para probar el tamaño, y fue un ajuste perfecto. Para la parte superior, empecé haciendo agujeros pequeños justo debajo del tapón e inserté un alambre metálico de unos 30 cm y hice un nudo arriba. Luego corté cuatro agujeros en cada lado, a diferentes alturas para aves de diferentes tamaños, y para que el olor de la semilla salga y atraiga más aves. Finalmente, deslicé la parte superior en la inferior y la aseguré con cinta de enmascarar, asegurándome de que la cinta no cubriera los sensores. Aunque usé cinta de enmascarar, cinta de embalaje transparente también funcionaría. Cuando todo estaba seguro, llené de semilla usando un embudo y lo puse afuera y esperé a que vinieran las aves.

Para la carcasa de botella del comedero, primero medí el diámetro de la botella tomando la etiqueta, encontrando la longitud (la circunferencia) y dividiéndola por pi. La botella resultó ser de unos 105mm de diámetro y basé todo el paquete alrededor de este número. Empecé haciendo una carcasa que pudiera sostener el Arduino y las dos protoboards, y una tapa que tuviera un asa para facilitar sacar el paquete. También hice una pequeña carcasa en la parte inferior que pudiera sostener el paquete de baterías, y la diseñé de forma que pudiera ahorrar la mitad del filamento que podría haber usado de otra forma. Decidimos ir aún más lejos con el sensor de presión así que creé una tapa que también ahorraba filamento manteniendo la misma rigidez.

Finalmente, imprimí la placa que ayudaría al sensor de presión y atornillé todas las piezas juntas. El resultado fue un paquete compacto que funcionó muy bien:

Probándolo

Probamos el comedero antes del despliegue. Hay varias áreas críticas de funcionalidad y las probamos sistemáticamente antes del despliegue.

Primero confirmamos la conectividad BLE en 2 partes. Primero, confirmamos el funcionamiento correcto del Arduino 101 para enviar notificaciones BLE usando la app nRF Master Control App. La he encontrado una herramienta confiable e indispensable para depurar mis proyectos BLE. Luego confirmamos que podíamos recibir señales desde fuera de la casa bien más allá del rango donde pensábamos colocar el comedero. Una vez que el Edison estuvo listo, reconfirmamos esto. Usar este enfoque nos permitió enfocarnos en una cosa a la vez. Aunque no es un proyecto ultra complejo, tiene suficientes piezas para causar confusión si no lo tomas paso a paso. Una cosa que descubrimos fue que cuando las pilas se agotaban, la primera función en perderse era BLE.

También hicimos calibración de nuestra FSR y encontramos resultados interesantes. Con nuestra plataforma de punto de contacto encontramos un rango lineal, dentro de una respuesta general no lineal a agregar semilla:

Por ahora, solo usamos estos valores para ajustar nuestros rangos min/max y colores en el gauge Eon.js del comedero, pero exploraremos esto en el futuro para poder estimar la alimentación con precisión.

Galería de Despliegue

La mejor parte de este proyecto tiene que ser revisar las fotos. Puedes hacer esto online en tu panel de Cloudinary o mirando los archivos almacenados en la tarjeta SD. Una vez que las aves descubren tu comedero ¡puedes generar fácilmente 2,000 JPEGs en el espacio de unas pocas horas! ¡Esto no es exageración!

Nota sobre alineación con Project FeederWatch.

¡Seeed Qué Traerá el Futuro!

Ya hemos comenzado a rediseñar y probar nuestro circuito usando el kit de SeeedStudio. No entramos en el concurso a tiempo para calificar para el hardware gratis, pero conseguimos un Grove Starter Kit por nuestra cuenta. Muy importante: la fuente de alimentación del Base Shield nos permite usar ambos sensores Sharp IR SIN los condensadores de soporte. Ambos sensores funcionan muy bien con él. Un beneficio adicional, como puedes ver en la imagen de abajo, es el diseño enormemente simplificado. ¡Esto es para un comedero y no un nido de pájaros! ¡Probablemente deberíamos haber empezado nuestro prototipado con el kit Grove de SeeedStudio!

El sensor infrarrojo estándar de Seeed no era el mismo que los sensores Sharp IR que usamos, así que modificamos ligeramente nuestros sensores para ser compatibles con el base shield. Simplemente soldando alambre de núcleo sólido a las líneas GND, Vin y SIG del sensor IR pudimos conectar:

Alineación con Project FeederWatch y Conclusión

Nuestra inspiración original para este proyecto fue unirnos a Project FeederWatch por primera vez. ¿Cómo se alinea nuestro comedero IoT con los objetivos y método de medición de Project FeederWatch?

Project FeederWatch tiene una metodología específica y validada para su conteo de aves. En un período de 2 días consecutivos, reportas el número máximo de aves de un cierto tipo vistas en un momento. Así que nuestros conteos de posaderos no coinciden realmente con esto. Sin embargo, medir parámetros ambientales y automatizar nuestro consumo de semilla definitivamente sí. También tomar fotos de las aves que visitan nuestro comedero nos ayuda a aprender identificaciones. Además, si un ave "rara" visitara, tendríamos la documentación fotográfica requerida para documentar esta visita.

El potencial de streaming en vivo de datos sobre la red de PubNub es enorme. Datos e imágenes podrían compartirse entre observadores de aves y aulas alrededor del mundo, ¡en vivo y en tiempo real! Un área que nos gustaría explorar es el bloque clarifai en PubNub. ¿Podríamos enviar la imagen almacenada en Cloudinary a clarifai para agregar detección de imágenes de aves y tipos de aves en nuestras imágenes? ¿Podríamos usar el bloque PubNub Cloudinary para ayudar a corregir la mala calidad de imagen debido a condiciones climáticas variables? ¿Qué otros sensores Seeed/Grove podríamos agregar?

Como makers geeks, este proyecto también fue muy divertido. Realmente disfrutamos viendo las aves en vivo en el comedero y luego volviendo a ver qué tipo de fotos capturamos fue como una mini caza del tesoro. Ver los datos de alimentación disminuir durante el día, mientras literalmente recopilábamos miles de JPEGs fue súper divertido. Y usar Arduinos, Edisons y mejorarlo con Grove y usar las tecnologías web de PubNub y Cloudinary para que todo funcione junto fue un gran desafío para nosotros... ¡oh sí, y mencionamos la impresión 3D?

¡Esperamos que te inspires para registrarte en FeederWatch y estés de acuerdo con nosotros que al final... ¡Es por los pájaros!

Código

¡Es Por Los Pájaros!

Todos los archivos de código necesarios para este proyecto están publicados aquí: https://github.com/lachendeKatze/ItsForTheBirds

Partes Personalizadas y Carcasas

Archivos .stl para nuestro proyecto

Estos son los archivos stl esenciales para construir tu comedero "en botella de refresco": https://github.com/lachendeKatze/ItsForTheBirds/tree/master/3DBuild

Esquemáticos

Este es el circuito que está embebido en el Comedero de Aves:

La parte del circuito del Edison es simple y no encontramos un componente Fritzing apropiado para la webcam, así que solo tomamos una foto.