"C'est pour les oiseaux !"

Outils et machines nécessaires

	Imprimante 3D (générique)
	Fer à souder (générique)

Applications et services en ligne

	Intel XDK pour IoT
	Autodesk Fusion 360
	API de publication/abonnement PubNub
	Cloudinary
	noble.js

À propos de ce projet

« C'est pour les oiseaux ! » Réinventer l'avenir de l'éco-surveillance avec l'Arduino 101

Présentation et motivation :

Une façon de mesurer la santé de notre climat et de l'écosystème dans lequel nous vivons est de mesurer la taille et la variété de sa faune ou de sa population animale. Chaque hiver, depuis 1987, le Cornell Lab of Ornithology mène un effort massif de science citoyenne appelé Project FeederWatch :

"Le projet FeederWatch est une enquête d'hiver sur les oiseaux qui visitent les mangeoires dans les arrière-cours, les centres naturels, les zones communautaires et d'autres lieux en Amérique du Nord… Les données de FeederWatch montrent quelles espèces d'oiseaux visitent les mangeoires dans des milliers d'endroits à travers le continent chaque hiver . Les données indiquent également combien d'individus de chaque espèce sont observés. Cette information peut être utilisée pour mesurer les changements dans les aires d'hivernage et l'abondance des espèces d'oiseaux au fil du temps. "

C'est notre première année de participation et nous voulions combiner notre intérêt pour la fabrication et le piratage, avec notre intérêt pour la nature et notre participation au projet FeederWatch. Nous avons donc décidé de réinventer notre avenir en matière d'observation des oiseaux et de surveillance environnementale avec l'Arduino 101 !

L'Arduino 101 est idéal pour ce projet car il combine la simplicité de l'IDE Arduino pour rendre notre programmation intégrée facile, des capacités embarquées telles que Bluetooth LE avec une multitude de capteurs et de cartes de dérivation facilement disponibles. En intégrant un Arduino 101 dans une mangeoire à oiseaux maison, nous avons développé une plate-forme expérimentale pour mesurer les paramètres météorologiques et surveiller l'activité des oiseaux à notre mangeoire. L'ajout de technologies IoT passionnantes de Cloudinary et PubNub nous a aidés à réinventer l'avenir de la surveillance de la santé de l'environnement et des écosystèmes !

Présentation du projet :

Le cœur de notre projet est un Arduino 101 intégré dans une mangeoire à oiseaux maison. Nous utilisons 2 capteurs de distance infrarouge Sharp pour détecter les oiseaux perchés sur un goujon en bois traversant les deux côtés de la mangeoire. Une résistance sensible à la force (FSR) est utilisée pour détecter la quantité de graines présente dans le chargeur. Une carte de dérivation de capteur de température et d'humidité Adafruit Si7021 est attachée aux broches i2c et est utilisée pour fournir nos données météorologiques physiques. L'Arduino 101 est configuré pour agir comme un périphérique BLE et envoyer les données de ces capteurs via BLE à une centrale BLE appareil. L'alimentation est fournie par 4 piles AA. Tous ces composants sont logés dans un boîtier imprimé en 3D personnalisé.

Nous utilisons un Intel Edison sur l'Arduino Breakout Board à la fois comme centrale BLE et comme passerelle Internet. Une webcam USB logitech c270 est connectée au port USB de la carte et utilisée pour prendre des photos lorsqu'une notification BLE est reçue qui indique une activité sur l'un des perchoirs. Ces images sont stockées localement sur une carte SD insérée dans la fente pour carte SD sur la carte de dérivation.

Nous profitons de la capacité WiFi d'Intel Edison pour l'utiliser comme passerelle Internet. Cela nous permet d'utiliser des super technologies telles que PubNub pour le streaming de données en temps réel et Cloudinary pour le stockage et la manipulation d'images dans le cloud.

La mangeoire pour oiseaux est fabriquée à partir d'une bouteille de soda vide et d'un goujon en bois et l'a suspendue à un poteau dans notre jardin.

Construire le projet :

Arduino 101 la mangeoire à oiseaux intégrée.

La base de ce projet est un Arduino 101 intégré dans notre mangeoire à oiseaux. La mangeoire à oiseaux sera à l'extérieur et devra être capable de résister aux rigueurs physiques d'être à l'extérieur. Il aura besoin d'un moyen de transmettre des données en temps réel et sans fil. La distance entre l'Arduino 101 émetteur et l'Edison récepteur n'est que de quelques pieds et comme l'Arduino 101 a déjà BLE à bord, nous utiliserons BLE !

La majeure partie du circuit peut être construite en suivant le schéma de frittage, mais nous avons rencontré quelques défis lors de la fabrication et du test de ce circuit. C'est sur celles-ci que nous allons nous concentrer ici :

• Le premier défi :Détecter un oiseau sur la mangeoire, en extérieur ! Pour ce projet, nous avons besoin d'un capteur capable de fonctionner à l'extérieur, scellé contre les éléments. Nous ne voulons pas que cela dérange ou effraie le sujet. Il ne devrait détecter que ce qui est sur le perchoir. Après avoir évalué les caractéristiques de divers capteurs, nous avons décidé d'utiliser le Pololu Carrier avec le capteur de distance numérique Sharp GP2Y0D815Z0F. Ces capteurs, contrairement aux capteurs PIR classiques, ont une portée de détection très courte. Nous voulons seulement savoir si un oiseau est perché à quelques centimètres du capteur. Les capteurs PIR ont une très longue et large plage de détection. C'est idéal pour détecter tout type de mouvement dans l'allée de votre maison, mais nous ne voulons pas que les branches d'arbres ou autres « bruits » soient détectés à chaque fois que la mangeoire à oiseaux se balance dans la brise. Une évaluation rapide sur paillasse a également montré que les capteurs IR Sharp fonctionnaient lorsqu'ils étaient placés à l'intérieur d'une bouteille de soda en plastique. Ceci est important car nous devons protéger l'électronique des éléments et être en mesure de « voir à travers » cette partie du boîtier.

• Le deuxième défi :après avoir branché l'un des capteurs et l'avoir testé, nous étions prêts à partir ! Nous avons donc connecté un deuxième capteur IR Sharp à l'Arduino 101 et . . .ils n'ont pas fonctionné ! Après avoir vérifié le code, plusieurs fois. Après avoir vérifié quelques cartes et différents capteurs, rien ne ferait fonctionner ces deux capteurs ensemble. Nous étions donc confrontés à notre 1er grand défi. Doit-on essayer un autre type de capteur ? Devrions-nous fabriquer une seule mangeoire à perche (boiteux !), que faire ? En désespoir de cause, nous avons fait ce que nous aurions dû faire la première fois, consultez le site Web, et sur la FAQ du produit, nous avons trouvé ceci :Ce capteur ne se comporte pas comme prévu :je reçois beaucoup de détection intermittente plus loin que la portée maximale du capteur et il ne détecte pas d'objets dans la plage de détection annoncée. Qu'est-ce qui ne va pas ? Des problèmes comme celui-ci peuvent être le résultat de problèmes d'alimentation, d'autant plus que ce capteur consomme de l'énergie en courtes et grandes rafales, alors assurez-vous que votre alimentation est capable de fournir le courant nécessaire. Si vous rencontrez ce problème, essayez d'ajouter un condensateur d'environ 10 µF entre l'alimentation et la terre du capteur près du capteur ; cela compense une alimentation électrique inadéquate et restaure généralement une fonctionnalité normale. Problème résolu! Nous avons ajouté un condensateur électrolytique de 47 uF à chacun des capteurs et ils ont fonctionné, avec un seul avertissement de plus, ils devaient tous les deux être alimentés directement à partir de la broche + 5 V de la carte. Vous verrez cela sur le diagramme fritz comme un cavalier du Ligne +5V d'un capteur à l'alimentation +5V de l'autre capteur. Nous ne sommes pas des EE, donc je ne peux pas expliquer cela, c'est juste ce que nous avons trouvé pour fonctionner à la fois à l'intérieur et à l'extérieur !

• Le troisième défi :dans la section Activités connexes et apprentissage du site Web du projet FeederWatch, l'une des activités recommandées est de peser les graines pour oiseaux dans votre mangeoire avant et après chaque comptage et de calculer la quantité de graines consommées. Après plusieurs comptages, calculez le taux de consommation moyen. Au lieu d'effectuer des pesées manuelles, pourquoi ne pas capturer la consommation de semences de manière automatisée ? Notre solution consistait à utiliser une résistance sensible à la force (FSR). Il s'agit d'une résistance dont la résistance varie en fonction de la force qui lui est appliquée. Il peut être connecté à une broche d'entrée analogique. Mais serait-il suffisamment sensible pour détecter les changements dans les quantités de graines ? Nos premières tentatives pour mesurer les niveaux de graines dans un petit récipient en plastique n'ont pas été très fructueuses. Le capteur a bien répondu aux variations de pression des doigts, mais pas aux niveaux de graines. Nous avons donc apporté deux modifications pour résoudre le problème. Tout d'abord, le signal analogique est délivré à la broche analogique Arduino 101 via un diviseur de tension à 2 résistances, l'un étant le FSR, le second étant une résistance conventionnelle. Nous avons baissé la valeur de cette deuxième résistance et le capteur semblait être plus sensible au toucher, mais il n'était toujours pas aussi réactif aux changements de graines que nous le souhaiterions. Donc ajouté dans un changement matériel à tout cela. Un peu par analogie au principe de Pascal, que si au lieu d'appliquer le poids des graines sur toute la surface du FSR, on créait une plate-forme avec un petit point de contact en son centre, on augmenterait considérablement la force de la graine sur le FSR. C'est tout le contraire d'une raquette et ça a marché !

Un autre défi mineur est de connecter le FSR à l'Arduino 101 de manière sécurisée et fiable. Ceci est facilement résolu par l'utilisation de borniers à 2 broches de 3,5 mm. Assurez-vous simplement que l'espacement du bornier correspond à celui de votre carte.

Le reste du matériel Arduino 101 est simple. Nous avons connecté la carte de dérivation Adafruit Si702 aux broches du bus I2C () et utilisé le +3,3 V vide pour l'alimentation. L'alimentation de l'ensemble est assurée par un bloc-piles commutable 4XAA logé sous le boîtier principal.

Nous avons soudé les capteurs IR et FSR aux PCB Adafruit Perma-Proto Quarter-size Breadboard et les avons attachés au dessous de l'Arduino 101 avec du ruban adhésif double face. L'ensemble de l'emballage est placé à l'intérieur de la mangeoire à oiseaux en bouteille de soda et a survécu à des températures glaciales inférieures à zéro, à la brume, à la pluie légère et à la neige (faux blizzard « Stella » !).

Arduino 101 Croquis :

Le travail principal du croquis consiste à surveiller les capteurs connectés et à signaler les valeurs des capteurs sur BLE. Toutes les données dans BLE sont transmises sous forme de paquet d'octets. Que vos données d'origine soient un int float ou un tableau de char, vous devrez les décomposer en sa représentation en octets pour les transmettre via BLE. La façon la plus simple que je connaisse de le faire est de créer une union de types de données. Une union nous permet de partager le même emplacement mémoire entre deux types de données différents. Dans notre cas, le capteur de température et d'humidité SI7021 fournit des données sous forme de nombre à virgule flottante. Le langage Arduino C représente un flotteur sous forme de 4 octets, nous créons donc une union entre notre flotteur de température et notre flotteur d'humidité et un tableau de 4 octets.

/** * La directive union permet à ces variables de partager le même emplacement mémoire. Veuillez consulter le * mon tutoriel Imu to You!(https://www.hackster.io/gov/imu-to-you-ae53e1?team=18045) pour plus de * discussion sur l'utilisation de la directive union dans C. */ union { float t; octets de caractères non signés[4] ; } tempData; union { flotteur h; octets de caractères non signés[4] ; } humiditéData; union { int f; octets de caractères non signés[2] ; } feedData;  

Lorsque nous stockons la valeur à virgule flottante dans l'union, le tableau d'octets est également rempli. Afin de transmettre les données, nous passons le tableau d'octets à la fonction setValue() de ces caractéristiques.

Pour les applications embarquées, l'utilisation des fonctions delay() peut poser des problèmes. Tout d'abord, pendant que la fonction de délai est appelée, toute l'activité du processeur s'arrête pendant la durée du délai. Ce n'est pas idéal lorsque les oiseaux peuvent venir se percher à tout moment. Un deuxième problème est que la fonction delay() peut entraîner des problèmes avec le mécanisme de notification BLE. Le moyen d'éviter cela est de ne pas utiliser delay() dans notre sketch. Il y a cependant, plusieurs fois, un retard dans le programme de code sera nécessaire. Pour surmonter cela, nous utiliserons la méthode décrite par dans cet ensemble de 3 super tutoriels de Bill Earl of Adafruit.

Dans les grandes lignes, nous créons un objet représentant notre appareil embarqué. Nous décidons d'un intervalle ou d'un ensemble d'intervalles pour interroger nos capteurs connectés à cet appareil. Nous créons ensuite une fonction Update().

void Update() { // Serial.print("Feed Sensor:");Serial.println(analogRead(A0)); // Les mises à jour/notifications d'activité de la perche dépendent de l'heure et des capteurs de proximité currentPerchMillis =millis(); if ((currentPerchMillis - previousPerchMillis)> perchInterval ) { previousPerchMillis =currentPerchMillis; currentLeftPerch =digitalRead(LEFT_PERCH); currentRightPerch =digitalRead(RIGHT_PERCH); if ((currentLeftPerch ==0) &&(previousLeftPerch ==1)) { // nouvelle activité sur le leftperch // BLE notifie perchCharacteristic.setValue(1); Serial.println("ACTIVITE PERCHE GAUCHE"); précédentLeftPerch =0; } ...}  

Cette fonction sert à vérifier si les intervalles de temps de nos capteurs sont écoulés, si c'est le cas, mettre à jour les capteurs, voire les ignorer. La fonction Update() est appelée à plusieurs reprises dans la section loop() de notre sketch.

void loop() { // mettez votre code principal ici, à exécuter à plusieurs reprises :blePeripheral.poll(); birdFeeder.Update(); }  

Nous émulons ainsi un effet multitâche en temps réel avec nos capteurs.

Intel Edison et Arduino Breakout Board :

La partie la plus difficile du travail avec Intel Edison est de le configurer. Le meilleur tutoriel que j'ai trouvé à ce sujet est Intel Edison et Intel XDK IoT Edition 101 de Vincent Wong. Je peux vous garantir que suivre ce processus et essayer certains des exemples JavaScript en vaut la peine !

Travailler avec votre Edison à l'aide de l'édition Intel XDK IoT vous permettra d'interagir et de le configurer sur la ligne de commande. Vous pourrez également profiter des nombreux exemples de programmes et modèles JavaScript/Node. Apprendre et utiliser JavaScript/Node pour programmer ouvrira un grand nombre d'API puissantes et faciles à utiliser, telles que PubNub, Noble.js et Cloudinary.

Une fois que vous avez configuré l'Edison et confirmé une connexion active à votre réseau WiFi, vous pouvez installer les bibliothèques nécessaires à ce projet :

npm install noble

npm installe pubnub

npm install cloudinary

La webcam USB

Une recherche sur google de "webcam intel edison" donnera plusieurs exemples et tutoriels intéressants. Mais il y a du matériel déroutant, qui, je pense, est principalement dû à quelques changements dans les modules disponibles dans le Yocto OS. Yocto est une version embarquée de linux qui exécute l'edison Intel. La Logitech c270 est une webcam compatible uvcvideo. Il existe de nombreux tutoriels pour s'assurer que votre Edison a le pilote/module uvcvideo installé. Sans cela, vous ne pourrez pas interagir et prendre des photos avec l'appareil photo.

J'ai utilisé les étapes suivantes de la caméra Web sur Intel Edison avec des téléchargements vers s3 pour que la webcam fonctionne sur mon Edison. J'ai posté les instructions de cet article de blog ci-dessous juste au cas où cela deviendrait un jour périmé.

Avec votre Edison, les instructions suivantes seront exécutées sur la ligne de commande dans l'onglet du terminal série XDK.

"Nous utiliserons des packages supplémentaires, qu'il est possible d'installer en utilisant opkg directeur chargé d'emballage. Pour le début, modifiez la liste des dépôts avec vi :

vi /etc/opkg/base-feeds.conf

et assurez-vous que vous avez toutes ces lignes dans le fichier :

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

Maintenant, mettez à jour le cache du package :

mise à jour opkg

Et installez le module du noyau pour prendre en charge les caméras USB uvc.

opkg install kernel-module-uvcvideo

Connectez maintenant votre webcam au port USB et exécutez cette commande.

ls -l /dev/video*

Si votre caméra est détectée avec succès, la sortie sera comme :

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

Pour travailler avec webcam et faire des photos dans les délais, nous devons installer 2 packages supplémentaires :

opkg install fswebcam copain

*** notez que nous n'avons pas installé Cronie pour ce projet, nous avons juste installé opkg fswebcam. cronie n'est pas nécessaire car nous appelons fswebcam chaque fois que les capteurs IR sont déclenchés par un oiseau sur un perchoir, pas selon un horaire programmé ***

Travailler avec la caméra

Pour tester votre caméra, exécutez cette commande :

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

• -r 1280x720 définissez la résolution de l'image, il est préférable d'utiliser le maximum disponible pour votre appareil photo (facultatif)

• — jpeg 100 réglez la qualité JPEG au maximum. C'est utile si vous allez faire quelque chose avec ces images plus tard (facultatif)

• -D 3 -S 13 ajoute 3 secondes de retard et saute les 13 premières images. C'est nécessaire, car certaines webcams ont besoin de temps pour obtenir les meilleures photos (recommandé)

• test.jpg est le nom du fichier de sortie "

Des informations supplémentaires sur l'utilisation d'une webcam avec l'Edison, et d'autres projets vraiment intéressants, peuvent être trouvées sur la page github du Dr Kim. Elle publie également des projets sympas sur Hackster.io !

En plus de confirmer que le module approprié était présent, je devais également basculer le commutateur entre les câbles microusb et le port USB dans la direction du port USB et attacher le blindage Arduino à une alimentation. J'ai utilisé l'alimentation à découpage compacte - Sortie sélectionnable 3-12VDC (ID de produit Adafruit :1448).

Placez maintenant votre carte SD dans la fente pour carte SD. Utilisation du terminal série dans Intel XDK, utilisez la ligne de commande pour vérifier la carte en entrant les commandes suivantes :

cd /media/sdcard

ls

Cela devrait afficher tous les fichiers présents sur la carte, ou rien s'il n'y a aucun fichier présent. Vous ne devriez voir aucun message d'erreur. Si vous voyez des messages d'erreur, je vous recommande de redémarrer la carte Edison sans retirer la carte SD en entrant cette commande :

redémarrer

Répétez ensuite les commandes ci-dessus après vous être reconnecté à votre Edison.

Maintenant, pour permettre à notre Edison d'accéder au Bluetooth, entrez la commande suivante :

rfkill débloque le bluetooth

Pour confirmer que le Bluetooth est activé et fonctionne, saisissez :

bluetoothctl

Tapez ensuite

scanner

Cela devrait s'afficher à proximité des appareils BLE en tant que tels :

Sortez maintenant de bluetoothctl, cliquez sur l'onglet Intel XDK IoT puis connectez-vous à votre carte. Sélectionnez un projet dans le menu de gauche, tel que BLESCAN. Éliminez le contenu de index.js et supprimez les dépendances du fichier package.json.

Remplacez le contenu de index.js par le programme de notre référentiel github ici. Téléchargez ce code sur votre Edison. Assurez-vous que l'Arduino 101 est allumé et exécutez le code Edison. Une fois que l'Edison a détecté votre Arduino 101, vous devriez voir quelque chose comme ceci :

Le Code :

Le code exécuté sur l'Edison est écrit en JavaScript ou plus exactement en Node.js. Après avoir créé les objets nécessaires à partir de nos bibliothèques importées, nous allons créer des variables pour représenter le service BLE qui s'exécute sur l'Arduino 101.

noble.js

 // Service et caractéristiques BLE pour noble // Ceux-ci doivent correspondre au service et aux UUID caractéristiques du périphérique // (sur l'Arduino 101 dans ce cas) var LOCAL_NAME ='bird'; var SERVICE_UUID ='917649a0d98e11e59eec0002a5d5c51b'; //pas de tirets!!!! var PERCH_UUID ='917649a1d98e11e59eec0002a5d5c51b'; var TEMPERATURE_UUID ='917649a2d98e11e59eec0002a5d5c51b'; var HUMIDITY_UUID ='917649a3d98e11e59eec0002a5d5c51b'; var FEED_UUID ='917649a4d98e11e59eec0002a5d5c51b';  

Ces UUID seront utilisés par noble.js. Si vous modifiez les UUID sur votre Arduino, ils doivent également être modifiés ici. Il est important de s'assurer que vous n'avez pas de tirets pour que noble.js fonctionne correctement.

Afin de travailler avec noble.js, nous devrons rechercher les périphériques BLE, puis les découvrir et ensuite nous connecter. Une fois connecté, nous passerons en revue les caractéristiques disponibles à utiliser, en utilisant l'UUID défini ci-dessus. Les caractéristiques sont toutes des caractéristiques de lecture/notification.

noble.on('discover', function(peripheral){ console.log('Found BLE Device :[' + devices.id + '] ' + devices.advertisement.localName); if(peripheral. publicite.localName ==LOCAL_NAME){ console.log('Found:' + device.advertisement.localName); } device.connect(function(error) { console.log('Connected to peripherique:' + peripherique.uuid); noble.stopScanning(); // nous empêche de récupérer les services "égarés" devices.discoverServices([SERVICE_UUID], function(error, services) { console.log('services:' + services.length); var feederService =services [0] ; console.log('Bird Feeder Service !'); feederService.discoverCharacteristics([], function(erreur, caractéristiques) { caractéristiques.forEach(function(caractéristique) { console.log('UUID caractéristique : ' + caractéristique .uuid); caractéristique.on('data', function(data, isNotification) { transformRawData(characteristic.uuid,data); }); caractéristique.notify('true', function(error) { if (error) throw e erreur ; }); }); }); }); }); });  

Il y a 2 éléments clés à souligner dans la section du code ci-dessus. Premièrement, il y a eu un changement dans la façon dont vous dites à noble.js qu'il s'agit d'une caractéristique de lecture/notification. Depuis la page github de Sandeep Mistry :

Données

Émis lorsque la lecture de la caractéristique est terminée, résultat de characteristic.read(...) ou la valeur caractéristique a été mise à jour par le périphérique via notification ou indication - après avoir été activée avec notify(true[, callback(error)]) .

caractéristique.on('données', callback(données, estNotification));

caractéristique.une fois('read', callback(data, isNotification)); // héritage

Le changement est de « lecture » ​​à « données ». Nous avons rencontré des problèmes ici par inadvertance en utilisant une ancienne version de noble, puis en changeant la version la plus récente. Il a fallu de nombreuses heures pour comprendre ce qui s'est passé, nous voulions donc potentiellement vous aider à éviter cela

L'autre clé ici est la fonction transformRawData(characteristic.uuid,data). Cette fonction prend l'uuid et les données fournies par la lecture et les transmet à la fonction volumineuse et lourde. Chaque fois que le mécanisme de notification BLE est activé par une modification d'une caractéristique, cette fonction est appelée et elle gère les données reçues. C'est là que toute l'excitation se produit.

tranformRawData vérifie quelle caractéristique est reçue.

Dans le cas où l'Arduino nous dit qu'il y a de l'activité sur le perchoir, nous voulons prendre une photo. Dans ce cas, nous utilisons la bibliothèque child_process pour faire un appel au programme fswebcam qui réside dans notre système Yocto(linux). La bibliothèque child_process nous permet d'exécuter des fonctions de ligne de commande à partir de notre code node.js. Il s'agit d'une fonctionnalité très puissante.

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

PubNub et Cloudinary :

Cette fonction est également là où PubNub et Cloudinary entrent en jeu ! PubNub fournit un réseau de streaming de données en temps réel à votre application. Cela signifie qu'avec une connexion Internet, votre application peut diffuser des données en direct partout dans le monde. Toute autre application ou programme disposant de la clé d'abonnement à vos flux publiés aura accès à une charge utile JSON représentant vos données. Dans notre cas, nous envoyons le niveau actuel de graines, la température, l'humidité et le nombre de visites de perches. De plus, nous envoyons un lien vers les 3 photos les plus récentes de la mangeoire ! Ce sont des jpegs qui ont été téléchargés sur Cloudinary avec notre programme. Il n'est pas nécessaire d'exécuter un serveur ! Un simple fichier HTML avec JavaScript intégré sert d'interface en temps réel à notre mangeoire à oiseaux avec l'aimable autorisation de PubNub !

Dans l'image ci-dessus, je me suis simplement envoyé par e-mail le fichier HTML contenant le code d'interface avec la mangeoire à oiseaux sur PubNub et j'ai chargé chacun d'eux à partir d'un répertoire local dans un navigateur Chrome. Vous n'avez pas besoin de coder un serveur pour diffuser cette page sur votre Edison.

Cloudinary est un service de téléchargement, de stockage et de transformation d'images. Son api très simple à utiliser. En développant ce projet, je n'ai pas pu trouver d'API plus simple et plus simple à utiliser. Il n'y a rien de comparable là-bas. Leur service d'assistance est également fantastique. C'est certainement quelque chose que vous voudrez vérifier pour vos projets!

Dans le code ci-dessous, nous utilisons l'API cloudinary pour télécharger les 3 dernières images de la carte SD locale. L'URL renvoyée par ce téléchargement est ensuite enregistrée dans un tableau. Ces URL sont ensuite envoyées dans le cadre de notre charge utile JSON à PubNub afin qu'elles puissent être consultées par notre page HTML à afficher. Beauté, hein ?!

index.html

De quoi parle ce fichier index.html ? Le fichier index.html est notre interface utilisateur. Étant donné que nous diffusons nos données en continu à l'aide de PubNub et plaçons nos images dans une URL accessible au public avec Cloudinary, nous pouvons profiter du trio de puissance Javascript/HTML/CSS pour créer une interface utilisateur portable. PubNub et Cloudinary sont tous deux très faciles à utiliser et puissants API Javascript. Nous les importons simplement dans notre fichier html pour les utiliser :

Lors de la création de l'objet PubNub, nous lui donnons la clé d'abonnement à notre flux de données et il peut accéder au flux de données en temps réel chaque fois que nous publions ce flux.