Complete Arduino & Intel Edison Starter Kit met Sensoren, Webcam en Essentiële Accessoires

Onderdelen en Benodigdheden

Onderdeel	Aantal	Opmerkingen
Arduino 101	1
Intel Edison	1
Logitech C270 HD Webcam	1
Pololu Carrier met Sharp GP2Y0D815Z0F Digitale Afstandssensor 15cm	2
Adafruit Vierkante Krachtgevoelige Weerstand (FSR) - Interlink 406	1
Adafruit Si7021 Temperatuur & Vochtigheid Sensor Breakout Board	1
Seeed Grove Starter Kit Plus, Intel IoT Editie	1
Condensator 47 µF	2
Weerstand 1k ohm	1
Adafruit Terminal Block - 2-pin 3.5mm - pak van 5	1
Adafruit Compact Schakelende Voeding - Selecteerbare Uitgang 3-12VDC	1
Adafruit Perma-Proto Kwart-formaat Breadboard PCB - Enkel	1
Draadjes (generic)	1

Benodigde Tools en Machines

• 3D-printer (generic)
• Solderbout (generic)

Apps en Online Services

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

Over Dit Project

"It's For The Birds!" – De Toekomst van Eco-monitoring Vernieuwen met de Arduino 101

Inleiding en Motivatie

Een manier om de gezondheid van ons klimaat en ecosysteem te meten, is door de omvang en diversiteit van de fauna of dierenpopulatie te meten. Elke winter, sinds 1987, organiseert de Cornell Lab of Ornithology een enorme citizen science-actie genaamd Project FeederWatch:

"Project FeederWatch is een winterlange telling van vogels die voederhuizen bezoeken in achtertuinen, natuurcentra, gemeenschapsgebieden en andere locaties in Noord-Amerika... FeederWatch-data tonen welke vogelsoorten voederhuizen bezoeken op duizenden locaties over het continent elke winter. De data geven ook aan hoeveel individuen per soort gezien worden. Deze informatie kan gebruikt worden om veranderingen in de wintergebieden en aantallen vogelsoorten in de loop van de tijd te meten."

Dit is ons eerste jaar dat we deelnemen en we wilden onze interesse in maken en hacken combineren met onze liefde voor natuur en deelname aan Project FeederWatch. We besloten onze toekomst van vogelobservatie en milieu-monitoring te vernieuwen met de Arduino 101!

De Arduino 101 is ideaal voor dit project omdat het de eenvoud van de Arduino IDE combineert met onboard mogelijkheden zoals Bluetooth LE en een rijk aanbod aan sensoren en breakout boards. Door een Arduino 101 in een zelfgemaakt voederhuis in te sluiten, ontwikkelden we een experimenteel platform om weersparameters te meten en vogelactiviteit te monitoren. Door IoT-technologieën van Cloudinary en PubNub toe te voegen, vernieuwden we de toekomst van omgevings- en ecosysteemgezondheidsmonitoring!

Projectoverzicht

Het hart van ons project is een Arduino 101 ingesloten in een zelfgemaakt voederhuis. We gebruiken 2 Sharp infrarode afstandssensoren om vogels te detecteren die op een houten dop zitten dat door beide kanten van het voederhuis loopt. Een krachtgevoelige weerstand (FSR) meet de hoeveelheid zaad in het voederhuis. Een Adafruit Si7021 temperatuur- en vochtigheidsensor breakout board is aangesloten op de I2C-pinnen en levert onze fysieke weersdata. De Arduino 101 fungeert als BLE-perrifere apparaat en stuurt data van deze sensoren via BLE naar een BLE-centraal apparaat. Voeding wordt geleverd door 4 AA-batterijen. Alle componenten zitten in een custom 3D-geprinte behuizing.

We gebruiken een Intel Edison op de Arduino Breakout Board zowel als BLE-centraal als als internetgateway. Een Logitech C270 USB-webcam is aangesloten op de USB-poort en wordt gebruikt om foto's te maken wanneer een BLE-notificatie aankomt die activiteit op een van de zithoeken aangeeft. Deze afbeeldingen worden lokaal opgeslagen op een SD-kaart in de SD-kaartslot op de breakout board.

We benutten de WiFi-mogelijkheid van de Intel Edison als internetgateway. Hierdoor kunnen we supertechnologieën zoals PubNub voor realtime datastreaming en Cloudinary voor afbeeldingsopslag en -manipulatie in de cloud gebruiken.

Het voederhuis is gemaakt van een lege frisdrankfles en een houten dop en hangt aan een paal in onze tuin.

Het Project Bouwen

Arduino 101: Het ingebedde voederhuis

De basis is een Arduino 101 in ons voederhuis. Het voederhuis staat buiten en moet weerbestendig zijn. Het moet data realtime en draadloos overdragen. De afstand tussen de zendende Arduino 101 en de ontvangende Edison is slechts enkele meters, en omdat de Arduino 101 al BLE heeft, gebruiken we BLE!

Het grootste deel van de schakeling kan gebouwd worden volgens het Fritzing-diagram, maar we liepen tegen een paar uitdagingen aan die we hier bespreken:

• Uitdaging 1: Een vogel detecteren op het voederhuis, buiten! We hadden een sensor nodig die buiten functioneert, afgedicht tegen de elementen, zonder de vogels te storen of weg te jagen. Het moet alleen detecteren wat op de zitplaats is. Na evaluatie van verschillende sensoren kozen we de Pololu Carrier met Sharp GP2Y0D815Z0F Digitale Afstandssensor. Deze sensoren hebben een zeer korte detectiebereik (in tegenstelling tot PIR-sensoren die lang en breed detecteren). We willen alleen weten of een vogel een paar centimeters van de sensor zit. PIR-sensoren detecteren takken en "ruis" telkens als het voederhuis in de wind beweegt. Een snelle test liet zien dat de Sharp IR-sensoren werkten wanneer ze in een plastic flesje geplaatst waren – belangrijk om de elektronica te beschermen en "door" de behuizing heen te kijken.
• Uitdaging 2: Twee Sharp IR-sensoren tegelijkertijd laten werken. Na het aansluiten van één sensor en testen, werkte het. Maar toen we een tweede aansloten, werkten ze niet meer samen. Na vele codechecks, andere borden en sensoren, bleken ze niet samen te werken. In wanhoop keken we op de product-FAQ's en vonden we: "Dit sensor gedraagt zich niet zoals verwacht: ik krijg intermittente detectie ver buiten het maximale bereik en het detecteert geen objecten binnen het geadverteerde bereik. Wat is er mis? Dit kan komen door voedingsproblemen, vooral omdat de sensor stroom trekt in korte, grote pulsen. Zorg dat je voeding de benodigde stroom kan leveren. Probeer een 10 µF condensator over de voeding van de sensor te plaatsen; dit compenseert een onvoldoende voeding en herstelt meestal de normale functionaliteit." Probleem opgelost! We voegden een 47uF electrolytische condensator toe aan elke sensor en ze werkten, met één voorbehoud: ze moesten allebei direct van de +5V-pin van het bord gevoed worden. Je ziet dit in het Fritzing-diagram als een jumper van de +5V-lijn van de ene sensor naar de +5V-voorziening van de andere. We zijn geen EE's, dus we kunnen het niet uitleggen, het werkt gewoon zowel binnen als buiten!
• Uitdaging 3: Zaadconsumptie automatisch meten. Op de Project FeederWatch-website wordt aanbevolen om het vogelzaad voor en na elke telling te wegen en de consumptie te berekenen. Waarom niet geautomatiseerd? Onze oplossing: een Force Sensitive Resistor (FSR). Dit is een weerstand wiens weerstand varieert met de toegepaste kracht. Het kan aangesloten worden op een analoge ingang. Maar was het gevoelig genoeg voor zaadniveaus? Onze eerste pogingen in een klein plastic bakje waren niet succesvol. De sensor reageerde goed op vingerdruk, maar niet op zaadniveaus. We maakten twee wijzigingen: (1) het analoge signaal loopt via een spanningsdeler met twee weerstanden (één de FSR, één conventionele). We verlaagde de waarde van de tweede weerstand, wat de gevoeligheid verbeterde, maar nog niet voldoende. (2) Een hardware-aanpassing: analogie met Pascal's principe – in plaats van het gewicht van het zaad over het hele FSR-oppervlak te verdelen, creëerden we een platform met een klein contactpunt in het midden, wat de kracht op de FSR sterk vergroot. Het werkte!

Het veilig aansluiten van de FSR op de Arduino 101 werd opgelost met 2-pin 3.5mm terminalblokken. Zorg dat de afstand van het terminalblok past op je bord.

De rest van de Arduino 101 hardware is simpel. De Adafruit Si7021 breakout board is aangesloten op de I2C-bus pinnen en gevoed via de vrije +3.3V. De volledige verpakking wordt gevoed door een 4xAA schakelbare batterijpakket onder de hoofdbeshuizing.

We solderden de IR- en FSR-sensoren op Adafruit Perma-Proto Quarter-sized Breadboard PCBs en plakten ze met dubbelzijdig tape onder de Arduino 101. Het hele pakket zit in het flesje-voederhuis en heeft sub-nul temperaturen, mist, lichte regen en sneeuw (vals blizzard 'Stella'!) doorstaan.

Arduino 101 Sketch

De hoofddoel van de sketch is de aangesloten sensoren monitoren en de waarden via BLE rapporteren. Alle data in BLE wordt als pakket bytes verzonden. Of je data nu een int, float of array van chars is, je moet het opsplitsen in de byte-representatie voor transmissie via BLE. De makkelijkste manier is een union van datatypen te maken. Een union laat ons hetzelfde geheugenlocatie delen tussen twee verschillende datatypen. In ons geval levert de Si7021 temperatuur- en vochtigheidsensor data als floating-point getal. De Arduino C taal representeert een float als 4 bytes, dus we maken een union tussen onze temperatuur-float en vochtigheid-float en een array van 4 bytes.

/** 
 * De union-richtlijn laat deze variabelen hetzelfde geheugenlocatie delen. 
 * Zie mijn tutorial Imu to You! (https://www.hackster.io/gov/imu-to-you-ae53e1?team=18045) 
 * voor meer discussie over het gebruik van union in 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;

Wanneer we de floating-point waarde in de union opslaan, wordt het byte-array gevuld. Om de data te verzenden, geven we het byte-array door aan de setValue() functie van de kenmerken.

Voor embedded toepassingen kan het gebruik van delay() problemen veroorzaken. Ten eerste stopt alle processoractiviteit tijdens de delay. Dit is niet ideaal als vogels op elk moment kunnen komen zitten. Ten tweede kan delay() problemen geven met het BLE-notificatiemechanisme. De oplossing is delay() niet te gebruiken. Er zijn echter momenten dat een vertraging in code nodig is. Hiervoor gebruiken we de methode uit de 3 uitstekende tutorials van Bill Earl van Adafruit.

Kort gezegd: we maken een object dat ons embedded apparaat vertegenwoordigt. We kiezen een interval of set van intervallen om onze sensoren te pollen. We maken een Update() functie.

void Update() {
  // Serial.print("Feed Sensor: "); Serial.println(analogRead(A0));
  // Perch Activity updates/notificaties hangen af van tijd en nabijheidssensoren
  currentPerchMillis = millis();
  if ((currentPerchMillis - previousPerchMillis) > perchInterval) {
    previousPerchMillis = currentPerchMillis;
    currentLeftPerch = digitalRead(LEFT_PERCH);
    currentRightPerch = digitalRead(RIGHT_PERCH);
    if ((currentLeftPerch == 0) && (previousLeftPerch == 1)) {
      // nieuwe activiteit op linker zitplaats
      // BLE notificeer
      perchCharacteristic.setValue(1);
      Serial.println("LEFT PERCH ACTIVITY");
      previousLeftPerch = 0;
    }
    ...
  }
}

Deze functie checkt of de tijdsintervallen voor onze sensoren verstreken zijn; zo ja, update de sensoren, zo nee, negeer ze. De Update() functie wordt herhaaldelijk aangeroepen in de loop() sectie.

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

Zo emuleren we een real-time, multitasking-effect met onze sensoren.

Intel Edison en Arduino Breakout Board

Het meest uitdagende aan de Intel Edison is de setup. De beste tutorial die ik vond is Vincent Wong's "Intel Edison and Intel XDK IoT Edition 101". Ik garandeer dat dit proces doorlopen en een paar JavaScript-voorbeelden proberen de moeite waard is!

Werken met de Edison via de Intel XDK IoT Edition stelt je in staat om via de commandoregel te interacteren en configureren. Je kunt ook profiteren van de vele JavaScript/Node voorbeeldprogramma's en templates. JavaScript/Node leren en gebruiken opent een groot aantal makkelijk te gebruiken en krachtige API's zoals PubNub, Noble.js en Cloudinary.

Zodra je de Edison hebt ingesteld en een actieve verbinding met je WiFi-netwerk hebt bevestigd, installeer de benodigde bibliotheken voor dit project:

npm install noble
npm install pubnub
npm install cloudinary

De USB-webcam

Een Google-zoekopdracht naar "intel edison webcam" levert diverse tutorials op. Er is echter verwarrend materiaal, waarschijnlijk door wijzigingen in modules in de Yocto OS. Yocto is een embedded Linux die de Intel Edison draait. De Logitech C270 is een UVC-video compatibele webcam. Er zijn talloze tutorials over het zorgen dat je Edison de uvcvideo driver/module heeft geïnstalleerd. Zonder deze kun je niet met de camera interacteren en foto's maken.

Ik gebruikte de volgende stappen van "Web camera on Intel Edison with uploads to s3" om de webcam werkend te krijgen. Ik plaats de instructies hier voor het geval de blog ooit verdwijnt.

Met je Edison, voer de volgende instructies uit op de commandoregel in de XDK seriële terminal-tab:

vi /etc/opkg/base-feeds.conf
# Zorg dat deze regels in het bestand staan:
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

opkg update
opkg install kernel-module-uvcvideo

Sluit je webcam aan op de USB-poort en voer uit:

ls -l /dev/video*

Als de camera gedetecteerd wordt, is de output ongeveer:

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

Installeer fswebcam (en optioneel cronie voor planning):

opkg install fswebcam cronie

Let op: we installeerden geen cronie, we roepen fswebcam aan wanneer de IR-sensoren getriggerd worden door een vogel, niet op een tijdschema.

Test je camera:

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

• -r 1280x720 stelt resolutie in (max beschikbaar voor je camera) (optioneel)
• --jpeg 100 stelt JPEG-kwaliteit in op maximum (optioneel)
• -D 3 -S 13 voegt 3 seconden vertraging toe en slaat de eerste 13 frames over (aanbevolen, sommige webcams hebben tijd nodig voor beste foto's)
• test.jpg is de uitvoerbestandsnaam

Extra informatie over webcam met Edison en andere leuke projecten vind je op Dr. Kim's GitHub-pagina. Ze plaatst ook coole projecten op Hackster.io!

Naast het bevestigen van de juiste module, moest ik de schakelaar tussen de micro-USB-kabels en de USB-poort richting de USB-poort omzetten en de Arduino-shield aan een voeding koppelen. Ik gebruikte de Compact Schakelende Voeding - Selecteerbare Uitgang 3-12VDC (Adafruit product-id: 1448).

Plaats nu je SD-kaart in de SD-kaartslot. Gebruik de Seriële Terminal in de Intel XDK om de kaart te checken:

cd /media/sdcard
ls

Dit moet eventuele bestanden tonen, of niets als de kaart leeg is. Je mag geen foutmeldingen zien. Als er fouten zijn, herstart de Edison zonder de SD-kaart te verwijderen:

reboot

Herhaal de commando's na opnieuw inloggen.

Om de Edison Bluetooth toegang te geven:

rfkill unblock bluetooth

Bevestig dat Bluetooth aanstaat en functioneert:

bluetoothctl
scan on

Dit zou nabijgelegen BLE-apparaten moeten tonen.

Verlaat bluetoothctl, ga naar de Intel XDK IoT-tab, verbind met je bord. Selecteer een project aan de linkerkant, zoals BLESCAN. Haal de inhoud van index.js eruit en verwijder de dependencies uit package.json.

Vervang de inhoud van index.js met de code uit onze GitHub-repository. Upload naar je Edison. Zorg dat de Arduino 101 aanstaat en draai de Edison-code. Zodra de Edison je Arduino 101 detecteert, zie je ongeveer dit:

De Code

De code op de Edison is geschreven in JavaScript (Node.js). Na het aanmaken van de benodigde objecten uit onze geïmporteerde bibliotheken, maken we variabelen voor de BLE-service die op de Arduino 101 draait.

noble.js

// BLE Service en Kenmerken voor noble
// Deze moeten overeenkomen met de peripheral's service en characteristic UUIDs (op de Arduino 101)
var LOCAL_NAME = 'bird';
var SERVICE_UUID = '917649a0d98e11e59eec0002a5d5c51b'; // geen streepjes!!!!
var PERCH_UUID = '917649a1d98e11e59eec0002a5d5c51b';
var TEMPERATURE_UUID = '917649a2d98e11e59eec0002a5d5c51b';
var HUMIDITY_UUID = '917649a3d98e11e59eec0002a5d5c51b';
var FEED_UUID = '917649a4d98e11e59eec0002a5d5c51b';

Deze UUIDs worden gebruikt door noble.js. Als je de UUID's op je Arduino wijzigt, moet je ze hier ook wijzigen. Belangrijk: geen streepjes voor noble.js.

Om met noble.js te werken, scannen we naar periferie BLE-apparaten, ontdekken ze en verbinden. Eenmaal verbonden, lopen we door de beschikbare kenmerken met de bovenstaande UUID's. Alle kenmerken zijn read/notify.

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(); // voorkom "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;
          });
        });
      });
    });
  });
});

Twee belangrijke punten uit bovenstaande code:

1. Er was een wijziging in hoe je noble.js vertelt dat dit een read/notification-karakteristiek is. Van Sandeep Mistry's GitHub: Data-event wordt geëmiteerd wanneer karakteristiek-lezen is voltooid, of wanneer de waarde geüpdatet wordt door de periferie via notificatie/indicatie – na inschakeling met notify(true[, callback(error)]). Het is gewijzigd van 'read' naar 'data'. We liepen hier per ongeluk tegen aan door een oudere versie van noble te gebruiken en daarna de nieuwste versie. Het kostte veel uren om te ontdekken wat er misging, dus we willen je helpen dit te vermijden.
2. De functie transformRawData(characteristic.uuid, data) neemt de uuid en data van de read en stuurt het door naar de grote functie. Elke keer dat het BLE-notificatiemechanisme geactiveerd wordt door een verandering in een karakteristiek, wordt deze functie aangeroepen en handelt de ontvangen data af. Hier gebeurt alle Spannende dingen.

transformRawData checkt welk karakteristiek ontvangen is.

Als de Arduino ons vertelt dat er activiteit is op de zitplaats, willen we een foto maken. We gebruiken de child_process library om fswebcam aan te roepen (die in ons Yocto/Linux-systeem zit). De child_process library stelt ons in staat om commandoregel-functies uit te voeren vanuit onze Node.js-code. Dit is een heel krachtige functie.

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

PubNub en Cloudinary

Deze functie is ook waar PubNub en Cloudinary in beeld komen! PubNub biedt een realtime datastreaming-netwerk voor je applicatie. Dit betekent dat met een internetverbinding je applicatie data live kan streamen naar overal ter wereld. Elke andere app of programma met de abonnementssleutel toegang heeft tot een JSON-payload die je data vertegenwoordigt. In ons geval sturen we het huidige zaadniveau, temperatuur, vochtigheid en bezoekaantallen op de zitplaatsen. Bovendien sturen we een link naar de 3 meest recente foto's van het voederhuis! Deze zijn JPEGs die geüpload zijn naar Cloudinary met ons programma. Er is geen server nodig! Een simpel HTML-bestand met ingesloten JavaScript fungeert als realtime interface naar ons voederhuis dankzij PubNub!

In de afbeelding hierboven heb ik mezelf het HTML-bestand gemaild dat de code bevat om via PubNub te interfacen met het voederhuis, en lokaal in een Chrome-browser geopend. Er is geen server nodig om deze pagina op je Edison te serveren.

Cloudinary is een afbeeldingsupload-, opslag- en transformatieservice. Het heeft een zeer eenvoudige API. Bij het ontwikkelen van dit project kon ik geen eenvoudigere, meer rechttoe-rechtaan API vinden. Hun helpdesk is fantastisch. Het is zeker iets wat je voor je projecten wilt bekijken!

In de onderstaande code gebruiken we de Cloudinary API om de 3 laatste afbeeldingen van de lokale SD-kaart te uploaden. De geretourneerde URL's worden in een array opgeslagen. Deze URL's worden vervolgens als onderdeel van onze JSON-payload naar PubNub gestuurd, zodat ze door ons HTML-bestand geopend en getoond kunnen worden. Mooi, toch?!

index.html

Wat doet dit index.html-bestand? Het is onze UI. Omdat we onze data streamen via PubNub en onze afbeeldingen plaatsen op een publiek bereikbare URL via Cloudinary, kunnen we de kracht van JavaScript/HTML/CSS gebruiken om een draagbare UI te maken. Zowel PubNub als Cloudinary hebben zeer makkelijk te gebruiken en krachtige JavaScript API's. We importeren ze simpelweg in ons HTML-bestand:

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

Bij het aanmaken van het PubNub-object geven we de subscribe-sleutel van onze datastroom op, zodat het realtime toegang heeft tot de datastroom wanneer we publiceren.

<script type="text/javascript">
var pubnub = new PubNub({
  subscribeKey: "jouw subscribe key hier",
});

Na aanmelding bij PubNub, doorloop een paar tutorials om te leren hoe je je pub en sub keys krijgt.

We hoeven geen Cloudinary-object te instantiëren in deze code om de 3 meest recente afbeeldingen te tonen. Onze PubNub-stream stuurt de URLs van deze afbeeldingen in de JSON-payload. We abonneren ons op het kanaal 'feederview' op onze stream, "decoderen" de payload en updaten en tonen de afbeeldingen:

// Abonneer op feederview kanaal
pubnub.subscribe({channels: ['feederView']});
// Decodeer JSON-payload wanneer nieuwe afbeeldingen binnenkomen
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 heeft een speciale bibliotheek voor grafische datavisualisatie: eon.js. Het is makkelijk te gebruiken en er zijn veel goede tutorials en een uitstekende webinar. Ik raad aan om deze door te nemen om te begrijpen hoe we onze data-display widgets maakten.

Voederhuis en Behuizing

Het bouwen van het voederhuis is eenvoudig. Voor de constructie snijd ik een perfect rechte lijn op een 2-liter fles op ongeveer 11 cm hoogte met een boxcutter. Daarna snijd ik gaten van ongeveer 3 cm hoog in het bodemstuk waar ik een houten dop door schuif die als zitplaats dient. Ik plaats het elektronica-pakket erin om de grootte te testen, en het past strak. Voor het bovenstuk prik ik kleine gaten net onder de dop en steek een metalen draad van ongeveer 30 cm door en maak een knoop bovenaan. Daarna snijd ik vier gaten aan elke kant, allemaal op verschillende hoogtes om verschillende vogelgroottes te accommoderen en de geur van het zaad te laten uitstomen om meer vogels aan te trekken. Ten slotte schuif ik het bovenstuk in het onderstuk en bevestig het met maskertape, zorgvuldig dat de tape de sensoren niet bedekt. Hoewel ik maskertape gebruikte, zou helder verpakkingswerk ook werken. Toen alles vast zat, vulde ik het zaad met een trechter en hingen we het buiten en wachtten op de vogels.

Voor de fles-behuizing meet ik de diameter door het label te nemen, de lengte (omtrek) te meten en door pi te delen. De fles was ongeveer 105mm in diameter en ik baseerde het hele pakket op dit getal. Ik begon met een behuizing die de Arduino en de twee breadboards kon houden, en een deksel met een handvat om het pakket makkelijk te kunnen uittrekken. Ik maakte ook een klein behuizingje onderaan voor het batterijpakket, en ontwierp het zo dat ik de helft van het filament bespaarde. We gingen nog verder met de druk-sensor, dus ik maakte een deksel dat ook filament bespaarde maar dezelfde rigiditeit had.

Ten slotte printte ik de plaat die de druk-sensor helpt en schroefde alle stukken samen. Het resultaat was een compact pakket dat prima functioneerde:

Testen

We testten het voederhuis voor de daadwerkelijke plaatsing. Er zijn diverse kritieke functionaliteitsgebieden en we testten ze systematisch.

Eerst bevestigden we BLE-connectiviteit in twee stappen. Eerst bevestigden we de juiste werking van de Arduino 101 om notificaties via BLE te sturen met de nRF Master Control App. Ik vind dit een onmisbaar en betrouwbaar hulpmiddel voor het debuggen van mijn BLE-projecten. Vervolgens bevestigden we dat we signalen van buitenaf goed ontvingen, ver buiten het bereik waar we het voederhuis wilden plaatsen. Zodra de Edison klaar was, herhaalden we dit. Deze aanpak liet ons stap voor stap focussen. Hoewel dit geen ultra-complex project is, heeft het genoeg onderdelen om verwarring te veroorzaken als je niet stap voor stap te werk gaat. Eén ding vonden we uit: als de batterijen leeg raakten, was de eerste functie die verdween BLE.

We deden ook kalibratie van onze FSR en vonden interessante resultaten. Met ons contactpunt-platform vonden we een lineair bereik, binnen een algeheel non-lineaire respons op het toevoegen van zaad:

Voor nu gebruikten we deze waarden om onze min/max en kleurbereiken op de Eon.js voeder-gauge aan te passen, maar we zullen dit in de toekomst verkennen om de voeding nauwkeurig te kunnen schatten.

Implementatie Galerij

Het beste deel van dit project is het bekijken van de foto's! Je kunt dit online doen in je Cloudinary-dashboard of door de bestanden op de SD-kaart te bekijken. Zodra de vogels je voederhuis ontdekken, kun je makkelijk 2.000 JPEGs genereren in een paar uur! Geen overdreven!

Opmerking over afstemming met Project FeederWatch.

Seeed Wat De Toekomst Brengt!

We hebben al begonnen met herontwerpen en testen van ons circuit met de SeeedStudio-kit. We waren niet tijdig voor de contest om gratis hardware te krijgen, maar we kochten een Grove Starter Kit zelf. Heel belangrijk: de voeding van de Base Shield laat ons ZONDER de ondersteunende condensatoren BEIDE Sharp IR-sensoren gebruiken! Beide sensoren functioneren prima met de Base Shield. Een extra voordeel is de vereenvoudigde layout. Dit is een voederhuis en geen vogelnest! We hadden eigenlijk moeten beginnen met de SeeedStudio Grove-kit!

De standaard infraroodsensor van Seeed was niet hetzelfde als de Sharp IR-sensoren die we gebruikten, dus we maakten onze sensoren lichtjes aangepast om compatibel te zijn met de Base Shield. Door simpelweg massieve draad te solderen aan de GND, Vin en SIG lijnen van de IR-sensor, konden we verbinden:

Afstemming met Project FeederWatch & Conclusie

Onze oorspronkelijke inspiratie was het deelnemen aan Project FeederWatch voor de eerste keer. Hoe stemt ons IoT-voederhuis af met de doelen en meetmethode van Project FeederWatch?

Project FeederWatch heeft een specifieke en gevalideerde methodologie voor hun vogeltelling. Over een periode van 2 opeenvolgende dagen rapporteer je het maximum aantal vogels van een bepaalde soort dat op één moment gezien wordt. Onze zitplaats-tellingen komen niet helemaal overeen. Maar het meten van omgevingsparameters en het automatiseren van onze zaadconsumptie wel. Het maken van foto's van bezoekende vogels helpt ons bij identificatie. Ook, als een "zeldzame" vogel ons voederhuis bezoekt, hebben we de fotodocumentatie om dit vast te leggen.

De potentie van live datastreaming via PubNub's netwerk is enorm. Data en afbeeldingen kunnen gedeeld worden tussen vogelwaarnemers en klassen over de hele wereld, live en realtime! Een gebied dat we willen verkennen is de Clarifai-block in PubNub. Kunnen we de afbeelding op Cloudinary naar Clarifai streamen voor vogelherkenning en soortenidentificatie? Kunnen we de PubNub Cloudinary-block gebruiken om slechte beeldkwaliteit door weeromstandigheden te corrigeren? Welke andere Seeed/Grove-sensoren kunnen we toevoegen?

Als geek-makers was dit project ook heel leuk. We genoten ervan om de vogels live te bekijken en daarna te kijken welke foto's we vingen – als een mini schatzoektocht! Het zien van de voedingsdata dalen over de dag, terwijl we letterlijk duizenden JPEGs verzamelden, was geweldig. En Arduino's, Edisons gebruiken en verbeteren met Grove, en webtechnologieën van PubNub en Cloudinary laten samenwerken was een geweldige uitdaging. Oh ja, en de 3D-printen?

We hopen dat je geïnspireerd raakt om je aan te melden voor FeederWatch en het met ons eens bent dat het er op neerkomt... Het is voor de vogels!

Code

It's For the Birds!

Alle codebestanden voor dit project zijn hier gepost: https://github.com/lachendeKatze/ItsForTheBirds

Aangepaste Onderdelen en Behuizingen

.stl-bestanden voor ons project

Dit zijn de essentiële stl-bestanden om je "in flesje" voederhuis te bouwen: https://github.com/lachendeKatze/ItsForTheBirds/tree/master/3DBuild

Schema's

Dit is de schakeling die in het voederhuis zit:

De Edison-deel van de schakeling is simpel en we vonden geen passend Fritzing-component voor de webcam, dus maakten we een foto.