Projet réalisé par Théo DELOOSE, Clara BOMY, Clément NOUGÉ, Mathieu GABRIEL, Marine DAEL et Thaï-Son DANG.

Introduction

Nous sommes six étudiants en troisième année à l’ISEN Lille. Dans le cadre de notre projet de fin d’année, nous avons conçu une serre connectée dédiée à un usage en intérieur. Celle-ci est équipée d’un système d’éclairage intelligent, d’une pompe d’arrosage automatique et d’un brumisateur intégré afin de garantir la bonne croissance des plantes, rassemblant les conditions nécessaires à leur développement. Pour une plus grande facilité d’utilisation, notre serre est associée à une application mobile simple et ludique permettant de suivre en temps réel les données de l’environnement de la serre et de contrôler celle-ci à distance.

En réalisant ce projet, notre but était de proposer une solution de serre connectée à un prix raisonnable et possédant une interface attrayante pour améliorer l’expérience de l’utilisateur.

De plus nous voulions que la serre puisse être intégrée dans différents systèmes facilement pour que l’utilisateur puisse utiliser les données à sa guise.

Fonctionnement général

Nous avons pensé FriendLeaf comme un système de monitoring et de pilotage. Il propose en effet de gérer automatiquement l’arrosage, l’humidité et la luminosité de la serre, ou bien de les activer manuellement à notre guise. Il synchronise les données récupérées par les différents capteurs grâce à la plateforme Constellation et active, par le biais d’un relais, les actionneurs. Enfin, FriendLeaf alerte l’utilisateur lorsque le réservoir d’eau est vide. Tout est synchronisé en temps réel comme par magie grâce à Constellation.

Nous avons donc ajouté dans la serre les capteurs permettant de relever les informations sur l’humidité de l’air et du sol, sur la température et sur la luminosité.  L’équipement installé comporte aussi une guirlande lumineuse ayant pour but d’éclairer et d’afficher les alertes, une pompe pour le système d’arrosage et un brumisateur permettant d’humidifier l’air.

Matériel utilisé

Pour réaliser notre projet, nous nous sommes servis des composants suivants :

Pour la Serre :

• Serre SOCKER Ikea (12,99€), Ikea
• Bac pour le terreau (1,50€), Jardinerie
• Carte Raspberry Pi 3B (40,80€), Amazon
• Relais 4 canaux supportant jusqu’à 5A et 250V (AC) et 30V (DC) (9,99€), Amazon
• Câbles de connexion
• Boîte de dérivation

Pour les capteurs :

• Humidité et température air : DHT11 (1,31€), Amazon
• Luminosité : TSL2561 (6,95€), Gotronic
• Humidité sol : GT110 (2,40€), Gotronic
• Niveau d’eau : Gravity SEN0205 (10,50€), Gotronic

Pour le brumisateur :

• Un émetteur à ultrasons (9,89€), Amazon
• Une alimentation pour le brumisateur (24V DC, 1A) (25€), Derotronic, Lille
• Un bol

Pour le système d’arrosage :

• Une pompe à eau (5,48€), Amazon
• Une alimentation 12V 600mA (12€), Derotronic, Lille
• Un jerrican (environ 10€)
• Un tuyau (ø7mm -ø10mm), Diall

Pour l’éclairage :

• 2m de guirlandes lumineuses (1m LED et 1m incandescent), Blachère
• Une alimentation pour fil lumière, Blachère
• Colliers de serrage

Conception de la serre

Étape 1 : Préparation de la serre

Dans la serre, nous avons disposé les capteurs, le pot et un bol pour le brumisateur. Nous avons également percé des trous pour pouvoir faire passer tous les capteurs et le tuyau d’arrosage.

Pour ce qui est de la guirlande lumineuse, il nous a fallu percer quelques trous supplémentaires dans les montants de la serre pour y glisser les colliers de serrage.

Étape 2 : Branchement du relais

Afin de pouvoir contrôler les actionneurs, nous avons branché le relais quatre canaux à une carte Raspberry Pi.

Celui-ci est analogue à un interrupteur. Pour chaque canal, une alimentation est nécessaire et chacun d’entre eux peut être piloté individuellement grâces aux différents pins dont dispose le relais. Il faut également prévoir une masse que l’on branche sur le pin “Gnd” du relais.

Par défaut, lorsque les pins d’entrée ne sont pas alimentés, les canaux du relais délivrent la tension d’alimentation correspondante sur la sortie NC (“Normally Closed”) ou sur la sortie NO (“Normally Open”) dans le cas contraire.

Etape 3 : Éclairage de la serre

Pour l’éclairage de notre serre, nous avons percé des trous dans la structure et fixé la guirlande avec des colliers de serrage. Celle-ci doit être alimentée par une tension de 230V (tension secteur) et est composée d’un mètre de LEDs rouge et d’un mètre incandescent jaune.

Elle est connectée au relais par la phase et le neutre, chacun branchés sur un canal différent, afin d’isoler totalement la guirlande du secteur et ainsi éviter tout problème avec le reste des composants.

Etape 4 : Installation du brumisateur

Pour augmenter l’humidité de l’air dans la serre, nous avons installé un brumisateur fonctionnant par émissions d’ultrasons. Il nécessite une alimentation de 24V/1A maximum. On le relie ensuite au relais. La masse est directement connectée à l’adaptateur secteur par le biais d’un domino.

Etape 5 : Installation du système d’arrosage

En ce qui concerne l’arrosage, nous disposons d’une pompe submersible qui nécessite une alimentation de 12V et 400mA. Elle est branchée en sortie à un tuyau percé pour un arrosage homogène. Nous la connectons ensuite à un des canaux du relais.

Pour le réservoir, nous avons récupéré un bidon de vinaigre de 5L sur lequel nous avons fait un trou pour le capteur de niveau d’eau et une ouverture pour le remplir et y faire passer la pompe.

Pour résumer…

Étape 6 : Mise en place des capteurs et paramétrage de la carte Arduino

Nous installons à présent les capteurs d’humidité/température de l’air, d’humidité du sol, de de luminosité et de niveau d’eau. Nous branchons tous ces capteurs aux pins de la Raspberry ou de l’Arduino en faisant attention au fait que :

• Les capteurs d’humidité du sol et de niveau d’eau se branchent sur du 5V.
• Les capteurs d’humidité/température de l’air et de luminosité sont alimentés en 3,3V.

Étape 6.1 : Capteur d’humidité et de température de l’air

Le capteur d’humidité et de température de l’air fournissant des données numériques, nous le relions directement à notre Raspberry Pi comme montré sur le schéma ci-dessous :

Étape 6.2 : Capteurs de luminosité, d’humidité du sol et de niveau d’eau

Ces capteurs fournissant des données analogiques, nous les avons branchés à une carte Arduino nano qui permet de lire ces données, contrairement à la Raspberry. Elle est reliée directement par USB à la Raspberry Pi comme montré ci-après :

Étape 6.3 : Programmation de la carte Arduino

Dans l’IDE Arduino, nous avons donc commencé par programmer la carte.

Nous ajoutons tout d’abord les librairies d’Adafruit pour pouvoir initialiser le capteur de luminosité et régler le temps d’intégration des données. Dans le gestionnaire de bibliothèque (menu Croquis > Inclure une bibliothèque), nous avons installé les librairies suivantes :

• Adafruit Unified Sensor
• Adafruit TSL2561

Au démarrage, dans la méthode “setup()”, nous configurons les pins utilisés. Nous décidons d’utiliser les pins analogiques A0 et A1, respectivement pour le capteur d’humidité du sol et du niveau d’eau et les pins A4 et A5 pour le capteur de luminosité :

void setup(void) 
{
  Serial.begin(9600);
 
  /*Réglage du capteur de luminosité*/
  if(!tsl.begin()) //Initialisation du capteur
  {
    //S'il y a un problème pour détecter le capteur, vérifier votre connexion
    Serial.print("Ooops, pas de capteur détecté... Vérifier votre connexion!");
    while(1);
  }
  
    //Configuration du gain du capteur et du temps d'intégration
    tsl.enableAutoRange(true);          
    tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_13MS);    
 
}

Dans la méthode “loop()”, nous recueillons ensuite les valeurs des capteurs et les faisons afficher sur le Monitor Série en utilisant les commandes analogRead() et Serial.print()  :

void loop(void) 
{  
  /*Pour recevoir une nouvelle donnée par le capteur de luminosité*/ 
  sensors_event_t event;
  tsl.getEvent(&event);
 
  //Lecture des pins analogiques pour les données des capteurs d'humidité du sol et de niveau d'eau
  Hum_value = analogRead(A0);
  Liquid_value=analogRead(A1);
 
  //Affichage des valeurs sur le Moniteur série
  Serial.print(event.light,0);
  Serial.print(',');
  Serial.print(map(Hum_value,0,1024,0,100)); //Le capteur d'humidité renvoie une valeur en pourcentage 
  Serial.print(',');
  Serial.println(map(Liquid_value,0,512,0,1)); //Le capteur de niveau d'eau retourne la valeur 1 quand il est en contact avec l'eau, 0 sinon
  delay(5000); //Retard de 5s pour éviter de surcharger le buffer de la Raspberry 
}

Nous récupèrerons ensuite les données des différents capteurs à l’aide de la carte Raspberry Pi.

La programmation vers Constellation

La programmation vers Constellation est divisée en deux packages : le premier correspond à la récupération des données des capteurs et à l’activation des actionneurs, le second a été créé pour gérer le stockage des données en vue de créer des graphiques sur notre application.

Etape 1 : Package relatif aux capteurs et actionneurs

Etape 1.1 : Acquisition des données des capteurs

Pour récupérer les données des différents capteurs cités précédemment, nous avons utilisé la librairie “Adafruit_DHT” pour Raspberry Pi et la librairie “serial” qui permet de faire le lien entre l’Arduino-Nano et la Raspberry Pi. Ces valeurs vont nous permettre de décider s’il faut activer ou non les actionneurs tels que la pompe, le brumisateur ou les LED.

La fonction ci-après permet de récupérer les valeurs des différents capteurs.

def getCapteur():
    humiditeAir, temperature = Adafruit_DHT.read_retry(11,4)
    lux, humiditeSol, eau = ser.readline()[:-2].split(",")

Nous avons ensuite créé un State Object rassemblant les valeurs d’humidité du sol, d’humidité de l’air, de température et de luminosité ambiante pour pouvoir les publier sur notre Constellation.

Constellation.PushStateObject("Capteurs", {"HumiditeSol": int(self.humiditeSol), "HumiditeAir": int(self.humiditeAir), "Temperature": int(self.temperature), "Luminosite": int(self.lux)}, "CapteursInfos")

Etape 1.2 : Activation et désactivation des différents actionneurs (brumisateur, guirlande lumineuse et pompe à eau)

Comme mentionné précédemment, les actionneurs sont reliés à la Raspberry Pi via un relais quatre canaux. Cela simplifie grandement la programmation : il nous suffit simplement de gérer l’ouverture et la fermeture des relais.

Nous avons donc fait en sorte que chaque actionneur soit associé à son relais grâce à la librairie GPIO de la Raspberry Pi. Ainsi, le code diffère seulement au niveau des numéros des pins utilisés par les actionneurs.

Voici un exemple du code de l’activation et de la désactivation de notre pompe :

GPIO.setmode(GPIO.BOARD)
GPIO.setup(12,GPIO.OUT)
GPIO.output(12,0)

Le pin 12 de la Raspberry est celui relié au relais contrôlant la pompe.

Etape 1.3 : Automatisation des actionneurs

Pour réaliser la fonction d’automatisation, nous nous sommes tout d’abord renseignés sur les conditions propices à la bonne croissance des plantes au niveau de l’humidité du sol et de l’air, de la luminosité et de la température de l’air.

Pour le brumisateur, nous avons choisi de l’activer si l’humidité est inférieure à 35% et de le désactiver si l’humidité remonte au dessus de 37%.

if humiditeAir > 37 and brumisateur:
    DesactiverBrumisateur()
elif humiditeAir < 35 and not brumisateur:
    ActiverBrumisateur()
    time.sleep(1)

Pour la pompe, le fonctionnement est différent. Puisque la diffusion de l’eau dans la terre est plus lente, nous activons la pompe pendant 5s avant de la désactiver pendant 30s pour laisser le temps au capteur de ressentir les changements.

if humiditeSol < 30 and not pompe:
    if self.ticks == 0:
            if self.next_water == 0:
                    ActiverPompe()
            self.next_water = 15
        else:
                    self.next_water -= 1
        elif humiditeSol > 30:
                    self.next_water = 0
    elif pompe:
            self.ticks += 1
               if self.ticks >= 3:
                    DesactiverPompe()
                       self.ticks = 0
time.sleep(1)

Ces différentes fonctions sont exécutées dans des threads séparés pour ne pas que le code soit bloquant.

Maintenant, il ne reste plus qu’à sécuriser notre système d’arrosage via le capteur de niveau d’eau. Connecté à la carte Arduino nano, ce capteur va nous renvoyer 1 s’il y a de l’eau dans le réservoir, 0 sinon.

Les données du capteur de niveau d’eau nous permettent d’arrêter le système d’arrosage lorsque le réservoir est presque vide et d’informer l’utilisateur via un PushBullet et l’allumage des LEDs qu’il faut remplir le réservoir.

Constellation.SendMessage("PushBullet", "PushNote", [ "FriendLead", "Le reservoir d'eau est vide"], Constellation.MessageScope.package)

Étape 2 : Package relatif au stockage des données

Afin d’historiser les valeurs des capteurs stockées dans un des State Objects du premier package, nous en avons créé un autre que l’on a déployé sur le même serveur que Constellation.

Ce package génère une base de données dans un fichier .csv qui est mis à jour toutes les minutes avec les nouvelles données.

Chaque ligne contient la date, l’heure, l’humidité du sol, l’humidité de l’air, la température et la luminosité.

@Constellation.StateObjectLink(package = "FriendLeafCapteurs", name = "Capteurs")
def RecupValue(stateObject):
    humiditeSol = stateObject.Value.HumiditeSol
    humiditeAir = stateObject.Value.HumiditeAir
    temperature = stateObject.Value.Temperature

Nous avons ensuite créé un message callback qui permet de visualiser le fichier CSV dans notre Constellation.

@Constellation.MessageCallback()
def LireBDD():
'''
: return string : La base de données 
'''
    file = open('BDD.csv','r')
    lines = file.readlines()
    return lines

L’interface utilisateur : l’application mobile de monitoring et de pilotage de la serre

Étape 1 : Le noyau de l’application

Pour développer l’application mobile nous nous sommes aidés de Cordova, un Framework permettant de créer des application Android et iOS avec des technologies web.

Nous avons également utilisé jQuery et AngularJS pour faciliter l’interaction entre Javascript et HTML.

De plus, pour gérer certaines fonctionnalités comme le traitement du CSV ou l’affichage des graphiques, nous avons utilisé des librairies externes comme PapaParser et Chartist. Finalement, pour embellir le CSS, nous avons utilisé le Framework SemanticUI qui ressemble en certain points à Bootstrap.

Étape 2 : Connexion à Constellation, State Object et Messages Callback

Pour nous connecter à Constellation avec AngularJS, nous avons utilisé ces lignes de codes :

Constellation.initializeClient(url_port, sha, "FriendLeaf");

Constellation.onConnectionStateChanged(function (change) {
   //suite
});

et une ligne de ce type pour chaque State Object :

Constellation.registerStateObjectLink("*", "FriendLeafCapteurs", "Actionneurs", "*", function (so) {
    //suite
});

Quant aux messages Callback, ils sont envoyés comme suit :

Constellation.sendMessage({ Scope: 'Package', Args: ['FriendLeafCapteurs'] }, 'DesactiverBrumisateur');

Pour que l’application soit utilisable sur n’importe quelle Constellation, nous avons créé un page de configuration où l’utilisateur rentre l’adresse de sa constellation, le port, et des identifiants.

Une fois tout cela rempli, le nom d’utilisateur et le mot de passe sont hachés en SHA1 grâce à une librairie externe et la connexion à Constellation commence.

Lorsque l’application se lance pour la première fois, l’utilisateur est directement redirigé vers cette page pour entrer les informations nécessaires.

Étape 3 : Affichage des données en temps réel

Pour l’affichage des données en temps réel nous avons utilisé des images SVG car elles sont très flexibles et nous voulions réaliser des barres de progression en arc de cercle. Pour les valeurs numériques on affiche un scope AngularJS dans lequel sont stockés les valeurs des capteurs.

Le code JS :

//Stockage des valeurs des capteurs dans la variable capteur
scope.capteurs["humiditeAir"] = so.Value.HumiditeAir;
scope.$apply(); //Applications des modifications du scope

//Pour changer le remplissage de la jauge 
$("#h_air_gauge").css("stroke-dasharray",(so.Value.HumiditeAir*18)/100 + " 18 0");

SVG en HTML :

<svg viewbox="0 0.5 10 8">
    <defs>
    <linearGradient id="linear" x1="0%" y1="0%" x2="100%" y2="0%">
        <stop offset="0%" stop-color="#00ee4f"/>
        <stop offset="66%" stop-color="#eeae00"/>
        <stop offset="100%" stop-color="#ee0000"/>
    </linearGradient>
    </defs>
    <text x="50%" y="50%" id="h_air_value" text-anchor="middle"  alignment-baseline="middle" fill="#00ee4f">
        {{Math.round(capteurs["humiditeAir"])}}%
    </text>
    <path d="M2 8 A 4 4 0 1 1 8 8" fill="none" stroke-width="0.78" stroke="#E8F6FD" />
    <path class="loader" id="h_air_gauge" d="M2 8 A 4 4 0 1 1 8 8" fill="none" stroke-width="0.8" 
stroke="url(#linear)" />
</svg>

Étape 4 : Contrôler sa serre

Nous avons également prévu dans l’application de pouvoir gérer les différents actionneurs de la serre.

Pour gérer le côté automatique du package responsable des capteurs nous avons utilisés des sliders qui lorsqu’activés, vont envoyer un Message Callback comme décrit ci-dessus. On va également suivre l’évolution du State Object indiquant si l’automatisation est activée pour tel ou tel actionneur et ainsi bloqué ou non le bouton d’activation manuel. Car oui, il est également possible d’activer manuellement chaque actionneur grâce à un bouton.

Étape 5 : Les graphiques

Pour ce qui est des graphiques nous avons utilisé une librairie externe que nous avons modifié pour la rendre compatible sur mobile. Cette librairie s’appelle Chartist. Grâce à elle nous avons pu faire de superbes graphiques.

Conclusion

Voilà qui conclut les grandes étapes de la réalisation de FriendLeaf. Comme vous avez pu le voir, la serre remplit complètement son rôle. C’est un projet ludique, simple à réaliser et facilement transposable sur d’autres installations grâce aux State Objects et aux messages Callback. C’est également un bon point de départ pour prendre en main la plateforme Constellation. Nous espérons vraiment qu’il vous a plu et que vous allez réaliser votre propre serre.

Nous tenons également à remercier Léa, le jardin de Théo et les parents de Marine qui nous ont fourni quelques accessoires nécessaires à la serre.

The post FriendLeaf : la serre connectée grâce à Constellation appeared first on Constellation.

Le code source du package est disponible sur : https://github.com/myconstellation/constellation-packages/tree/master/Pushover

Installation

Prérequis : création du compte Pushover

Tout d’abord vous devez vous inscrire sur https://pushover.net/

Ensuite installez les clients sur vos appareils (Desktop, Android et/ou iOS).

Vous pourrez alors enregistrer vos différents appareils. Le client coute 4,99$ (en une fois, pas d’abonnement) par type de plateforme que vous pouvez installer sur tous vos appareils.

Sur le Dashboard, notez votre ID d’utilisateur en haut à droite :

Pour finir, vous devez déclarer une application dans Pushover. Pour cela sur le dashboard, cliquez sur “Register an Application/Create an API Token” :

Vous pourrez alors spécifier le nom de votre application, le logo (qui sera utilisé sur vos appareils), etc..

Sur la page de detail vous pourrez suivre la consommation/stat de votre application et surtout récupérer l’API Token indispensable pour la configuration du package Constellation :

Installation du package dans Constellation

Depuis le “Online Package Repository” de votre Console Constellation, déployez le package Puhover :

Une fois le package télécharger votre repository local, sélectionnez la sentinelle sur laquelle déployer le package.

Pour finir, sur la page de Settings, vous devez obligatoirement définir le votre l’API Token délivré par Pushover et l’ID de votre utilisateur Pushover qui sera le destinataire par défaut des notifications envoyés par le package.

Vous pouvez également déployer ce package manuellement dans la configuration de votre Constellation :

<package name="Pushover">
  <settings>
    <setting key="Token" value="<< Pushover API token >>" />
    <setting key="UserId" value="<< Pushover User Id >>" />
  </settings>
</package>

Détails du package

Les Settings

Les StateObjects

Vous retrouverez autant de StateObject que de compteur de performance enregistrés dans la configuration de votre package.

Les MessageCallbacks

Le package expose 2 MessageCallbacks :

Quelques tests depuis la Console Constellation

Envoyer une notification

Pour tester son bon fonctionnement, depuis le MessageCallbacks Explorer de la Console Console, recherchez le MC “PushNotification” :

Ce MessageCallback prend plusieurs paramètres dont beaucoup optionnels. Le seul obligatoire étant le “message”.

Par exemple écrivons comme message “Hello world” et cliquons sur “Invoke” :

Comme le message est envoyé dans une saga, la Console vous affichera la réponse du package dans la barre de notification du haut :

Le message de retour de cette saga vous indiquera le statuts de la notification. Vous avez donc la possibilité dans vos applications/objets de savoir si la notification a bien été envoyée :

Ici sur mon smartphone Android, la notification est bien réceptionnée :

Envoyer une notification “urgente” avec acquittement

Testons maintenant une notification “urgente”, c’est à dire que la notification sera retransmise à intervalle régulier tant qu’un l’utilisateur ne l’acquitte pas.

Pour cela sélectionnez “Emergency” pour le paramètre “priority”. Vous pouvez également définir les champs retry/expire autrement ceux sont les valeurs de la configuration du package qui seront utilisées.

Dans le message de retour de la saga vous obtiendrez l’ID du reçu.

Sur un Android, la notification est accompagnée d’un bouton pour acquitter la notification.

Toujours dans le MessageCallbacks Explorer de la Console Constellation, vous pouvez invoquer le MC “GetNotificationStatus” en spécifiant l’ID du reçu :

Le message de retour nous indique que la notification a bien été délivrée (Status = 1) mais n’est pas encore acquittée.

Acquittez ensuite la notificaiton sur votre appareil Android ou iOS et invoquez de nouveau le MC “GetNotificationStatus”  :

Cette fois ci on constate bien que la notification a bien été acquitté (a telle heure, par tel utilisateur et sur tel appareil, ici le XperiaZ5).

Quelques exemples

• Envoyer une notification urgente si votre site Web est offline avec un package C#

The post Pushover : push de notifications sur Android, iOS et navigateurs appeared first on Constellation.

Vous pouvez installer les clients PushBullet sur Android, iOS, Windows et directement dans les navigateurs (sous forme d’extension) Chrome, Firefox, Safari ou Opéra.

Le package PushBullet pour Constellation vous permettra :

• d’envoyer des notifications texte
• d’envoyer des fichiers
• d’envoyer des liens
• d’envoyer des SMS de vos smartphones Android
• de copier un texte dans le presse-papier (avec un abonnement PushBullet Prenium)
• de récupérer des informations sur l’état de vos devices et utilisateurs connectés au service

Le code source de ce package est en ligne sur : https://github.com/myconstellation/constellation-packages/tree/master/PushBullet

Installation

Prérequis : PushBullet

Pour démarrer vous devez créer un compte sur https://www.pushbullet.com/.

Une fois votre compte activé, installer des clients PushBullet sur vos différents devices, par exemple votre smartphone (iOS ou Android) et dans votre navigateur.

Dès à présent, les notifications de votre smartphone seront partagées avec votre navigateur. Vous pourrez également depuis votre navigateur lire/écrire des SMS, etc…

Pour finir, dans les options de votre compte PushBullet, créer un “Access Token” qui servira pour connecter le package Constellation à votre comte PushBullet :

Installation du package

Depuis le “Online Package Repository” de votre Console Constellation, déployez le package PushBullet :

Une fois le package télécharger votre repository local, sélectionnez la sentinelle sur laquelle déployer le package :

Pour finir entrez le token dans la page de Settings et vous pouvez déployer votre package :

Vous pouvez également déployer ce package manuellement dans la configuration de votre Constellation :

<package name="PushBullet">
  <settings>
    <setting key="token" value="<< access token >>" />
  </settings>
</package>

Détails du package

Les Settings

Les StateObjects

Vous retrouverez 4 StateObjects publiés par le package :

Les MessageCallbacks

Le package expose 9 MessageCallbacks :

Quelques exemples

Tester l’envoi d’une notification depuis la Console Constellation

Le MC pour envoyer une simple notification se nomme “PushNote” :

Il prend en paramètre :

• Le titre de la notification
• Le texte de la notification
• Le type de la cible pour la notification
• L’argument de la cible

La cible (target) est une énumération :

Vous pouvez envoyer votre notification à un de vos devices, à un autre utilisateur (identifié par son mail), à un canal ou un client Web.

Dans notre cas, sélectionnons la cible par default “Device” et laissons le champs “targetArgument” afin de recevoir la notification sur tous nos devices enregistrés sur PushBullet et cliquons sur “Invoke” :

Votre notification sera instantanément reçue sur votre Smartphone :

Ici la notification reçue par Chrome sur un poste Windows :

Avec une smartwatch associée à votre téléphone, vous recevrez également vos notifications à votre poignet:

Envoyer des notification texte ou image depuis un package C#

N’hésitez pas dans le MessageCallbacks Explorer, à cliquer sur le bouton  afin d’ouvrir le générateur de code pour invoquer le MC sélectionné avec les différentes API Constellation.

Ici en sélectionnant le langage C# :

Pour envoyer notre notification de puis un package C# on écrira :

PackageHost.CreateMessageProxy("PushBullet").PushNote("Constellation", "Ceci est un test");

Les deux derniers paramètres étant optionnels (target et targetArguments) vous pouvez les omettre !

Autre solution, générer du code avec le générateur inclus dans le SDK Constellation. Sélectionnez simplement le package “PushBullet” dans le générateur de code :

Vous pouvez ensuite invoquer vos MC dans votre code C# à partir du code générer profitant ainsi de l’auto-complétion et de la documentation directement dans votre IDE :

Par exemple pour envoyer une image vous pouvez invoquer le MC “PushFile” en spécifiant l’URI (file:// ou http(s)://) vers le fichier à envoyer. Si vous souhaitez envoyer une notification avec l’image de votre caméra par exemple :

MyConstellation.Packages.PushBullet.CreatePushBulletScope().PushFile(urlImageCamera, "Porte de garage ouverte");

L’image sera alors envoyée sur tous vos devices :

Tutoriels

Il n'y a pas encore de tutoriel exploitant ce package !

Lister ses devices et envoyer des notifications depuis une page Web

Prenons une page HTML que nous allons connecter à Constellation avec AngularJS (documentation ici).

Lorsque la page sera connectée à Constellation, enregistrons un lien vers le StateObject nommé “Devices” pour le package “PushBullet” afin d’enregistrer la liste des devices (propriété “Devices”) de la valeur du StateObject dans une variable de scope Angular sans oublier de faire un “$apply” pour rafraichir le scope AngularJS :

constellation.registerStateObjectLink("*", "PushBullet", "Devices", "*", function(so) { 
    $scope.myDevices = so.Value.Devices;
    $scope.$apply();
});

Enfin dans le corps de votre page HTML, affcher une liste à point pour chaque device en affichant différentes informations comme le nom, fabriquant et modele de vos device :

<body ng-controller="DemoController">
  My devices :
  <ul>
    <li ng-repeat="device in myDevices">{{device.Nickname}} ({{device.Manufacturer}} {{device.Model}}
  </ul>
</body>

Allons un peu plus loin en ajoutant un bouton sur chaque device pour envoyer une notification (PushNote) au device spécifiquement sélectionné. Dans le <li> ajoutons :

<a href="#" ng-click="sendPush(device)">Send Push</a>

Et bien sûr déclarons la fonction “sendPush” dans notre scope pour invoquer le MC “PushNote” de notre package PushBullet en spécifiant l’ID du device destinataire de ce push et non tous les devices :

$scope.sendPush = function(device) {
  constellation.sendMessage({ Scope: 'Package', Args: ['PushBullet'] }, 'PushNote', [ "DemoJS", "Hello " + device.Nickname + " from JS", 'Device',
};

Et voilà, aussi simple que cela !

Le code complet de la page :

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" ng-app="demoApp">
<head>
    <title>Test API AngularJS</title>
    <script type="text/javascript" src="//code.jquery.com/jquery-2.2.4.min.js"></script>
    <script type="text/javascript" src="https://ajax.aspnetcdn.com/ajax/signalr/jquery.signalr-2.2.1.min.js"></script>
    <script type="text/javascript" src="//cdn.myconstellation.io/js/Constellation-1.8.1.min.js"></script>
    <script type="text/javascript" src="//ajax.googleapis.com/ajax/libs/angularjs/1.5.7/angular.min.js"></script>
    <script type="text/javascript" src="//cdn.myconstellation.io/js/ngConstellation-1.8.1.min.js"></script>
    
    <script>

    var demo = angular.module('demoApp', ['ngConstellation']);
    demo.controller('DemoController', ['$scope', 'constellationConsumer', function ($scope, constellation) {

        constellation.initializeClient("https://skynet.ajsinfo.net/constellation/", "9eBsRK5FFS5h36cM3OeE74qaDhlxCE2", "TestAPI");
            
        constellation.onConnectionStateChanged(function (change) {
            if (change.newState === $.signalR.connectionState.connected) {
                console.log("Connected to the Constellation");
                constellation.registerStateObjectLink("*", "PushBullet", "Devices", "*", function(so) {                    
                    $scope.myDevices = so.Value.Devices;
                    $scope.$apply();
                });
            }
        });
        
        $scope.sendPush = function(device) {
            constellation.sendMessage({ Scope: 'Package', Args: ['PushBullet'] }, 'PushNote', [ "DemoJS", "Hello " + device.Nickname + " from JS", 'Device', device.Id ]);
        };
        
        constellation.connect();
    }]);

    </script>

</head>
<body ng-controller="DemoController">

    My devices :
    <ul>
        <li ng-repeat="device in myDevices">{{device.Nickname}} ({{device.Manufacturer}} {{device.Model}}) <a href="#" ng-click="sendPush(device)">Send Push</a></li>
    </ul>
    
</body>
</html>

Recevoir des SMS depuis un Arduino/ESP

Si le paramètre “SendEphemeralsReceivedToGroup” n’est pas vide, le package enverra les “Ephemerals” comme les SMS reçus au groupe que vous avez spécifié par ce paramètre. Par défaut, il est défini à “PushBullet”, c’est à dire que si vous vous abonnez au groupe “PushBullet” vous recevrez les SMS et autre de notification de votre smartphone.

Prenons par exemple la page Web AngularJS créée ci-dessus pour bien comprendre. Lorsque votre page est connectée à Constellation, ajoutez le code suivant :

constellation.subscribeMessages("PushBullet");

Puis ajoutez un MessageCallback de votre page pour réceptionner le message nommé “ReceiveEphemeral”. On affichera alors le message reçu dans la console de notre navigateur pour comprendre ce que le package envoie :

constellation.registerMessageCallback("ReceiveEphemeral", function(msg) {
  console.log(msg);
});

Lancez votre page et envoyez-vous un SMS :

Le message est bien reçu du package PushBullet (propriété Sender) avec la clé (identifiant du MessageCallback) “ReceiveEphemeral”. Le contenu du message (Data) contient :

• L’identifiant du device qui a reçu la notification
• Le type de notification. Pour une notification liée à la réception d’un SMS cette valeur est à “sms_changed”
• Le tableau contenant le ou les notifications

Si la notification de l’“Ephemeral” est de type “sms_changed”, le tableau des notifications contiendra les SMS reçus avec le nom du contact émetteur du SMS (title), le texte du SMS (body) et la date de réception (timestamp).

Enfin, lorsque vous ouvrez le SMS reçu sur votre Smartphone vous allez faire disparaitre la notification ce qui enverra un autre “Ephemeral” de type “dismissal” pour le package “sms” :

Il devient alors facile de réaliser un petit objet connecté qui serait capable de nous prévenir en faisant clignoter une LED par exemple, lorsque nous recevons un SMS et d’arrêter cette LED lorsque vous nous faisons disparaitre la notification sur notre Smartphone.

Dans la méthode “setup()” nous allons abonnez notre ESP au groupe “PushBullet” :

constellation.subscribeToGroup("PushBullet");

Notez que vous pouvez également abonner votre package depuis la Console Constellation.

Ajoutons ensuite un MessageCallback “ReceiveEphemeral” pour définir si oui ou non nous devons faire clignoter une LED :

constellation.registerMessageCallback("ReceiveEphemeral",
  [](JsonObject& json) {
    if(json["Data"]["type"] == "sms_changed") {
      Serial.println("New SMS received");
      blinkLed = true;
    }
    else if(json["Data"]["type"] == "dismissal") {
      Serial.println("SMS readed");
      blinkLed = false;
    }
});

De ce fait déclarons cette variable ainsi que d’autre :

bool blinkLed = false;
int ledState = LOW;
unsigned long previousMillis = 0;
const int ledPin = LED_BUILTIN;
const long interval = 1000;

Pour faire clignoter la LED sans bloquer le programme avec des delay(), ajoutons la méthode suivante :

void driveLed() {
  if(blinkLed) {
    unsigned long currentMillis = millis();
    if(currentMillis - previousMillis >= interval) {
      previousMillis = currentMillis;
      ledState = ledState == LOW ? HIGH: LOW; // Switches led state
    }
  }
  else ledState = LOW; 
  digitalWrite(ledPin, ledState);
}

Pour finir dans la boucle principale, appellons notre méthode “driveLed” poru faire clignoter ou éteindre la LED en fonction :

void loop(void) {
  constellation.loop();
  driveLed();
}

Et voilà comment notifier la réception de SMS avec un LED drivée par un ESP8266 connecté à Constellation !

Envoyer un SMS depuis un simple appel HTTP

Si vous avez installé un client PushBullet sur un smartphone Android, vous pouvez l’utiliser en tant que passerelle SMS avec le MessageCallback “SendSMS” :

Ce MC prend en paramètre :

• L’ID de l’utilisateur
• L’ID du device qui sera utilisé comme passerelle SMS (ce device doit être un téléphone sous Android)
• Le n° du destinataire du SMS
• Le texte du SMS

Pour récupérer votre ID d’utilisateur, affichez les détails du StateObject “CurrentUser” :

Faites de même pour récupérer l’ID de votre device Android en visualisant le StateObject “Devices” :

Cliquez ensuite sur l’icone dans le MessageCallback Explorer pour afficher le code snippet du MC “SendSMS” en sélectionnant en tant que langage “HTTP Call” :

L’exemple est donné pour l’API Rest Constellation mais vous pouvez aussi utiliser l’API Rest Consumer en remplaçant “/rest/constellation” par “/rest/consumer”.

De ce fait, pour envoyer un SMS depuis un appel HTTP :

https://constellation.monserver.com/rest/consumer/SendMessage?SentinelName=Consumer&PackageName=DemoConstellation&AccessKey=xxxx&scope=Package&args=PushBullet&key=SendSMS&data=[ "mon_user_id_ici", "mon_device_id_android_ici", "0600000000", "Hello, ceci est un sms de test envoyé depuis l'API REST de Constellation" ]

Sans oublier bien sûr de remplacer le “xxxx” par une AccessKey valide de votre Constellation.

The post PushBullet : envoyer des notifications, images, SMS sur vos différents devices appeared first on Constellation.