Introduction

Étudiants en 3^ème année à l’ISEN-Lille, nous avons eu l’idée de développer une boîte aux lettres connectée en utilisant la plateforme Constellation.

En réalisant ce projet, nous voulions proposer une solution de boîte aux lettres connectée à un prix raisonnable et possédant une interface fluide pour améliorer l’expérience de l’utilisateur. Pour cela, nous avons acheté des composants peu coûteux à placer sur notre boîte aux lettres, et développé une application Ionic.

Notre boîte aux lettres est connectée à la plateforme Constellation par le biais d’un ESP8266, vous pouvez le connecter facilement à votre Constellation en suivant cette documentation sur le site Constellation.

Nous détectons ensuite la présence de courriers à l’aide de capteurs à ultrasons.

Avec un lecteur de cartes NFC, nous contrôlons l’accès à notre boîte aux lettres. Celui-ci nous permet de savoir qui a ouvert la boîte aux lettres et donc d’envoyer les bonnes informations à notre Constellation. Le lecteur NFC nous permet également de vérifier qu’une carte ou qu’un badge a les autorisations nécessaires afin de commander l’ouverture via un servo-moteur.

L’application, développée avec le framework ionic nous permet d’offrir une interface utilisateur ergonomique. En la connectant à Constellation, l’utilisateur a accès à toutes les informations nécessaires très facilement.

La boîte aux lettres connectée

Prérequis : Avoir connecté l’ESP8266 à Constellation.

Composants utilisés

Pour connecter notre boîte aux lettres à Constellation, nous avons utilisé :

• Un ESP8266 D1 Mini (8€ sur Amazon)
• Des capteurs à ultrasons HC SR04 (3€ sur Amazon)
• Un lecteur de cartes NFC (8€ sur Amazon)
• Un servo-moteur (6€ sur eBay)

Voici la correspondance pour définir les différents pins avec cet ESP :

Etape 1 : Détecter la présence d’une lettre grâce à un capteur ultrason

Nos capteurs fonctionnent avec une alimentation de 5V

Les capteurs à ultrasons nous permettent de mesurer une distance en créant une impulsion sur une des broches. Grâce à cette mesure, nous pouvons détecter une variation de la distance lorsqu’un courrier et inséré dans la boîte aux lettres. Nous envoyons alors l’information à Constellation grâce à un MessageCallback.

Relier le capteur à notre ESP est assez simple, notre capteur à ultrasons possède 4 branches, chacune branchée sur un pin de notre ESP.

Ci-dessous, les correspondances entre les branches du capteur à ultrasons et les pins de l’ESP8266 :

Dans notre code, nous configurons les pins dans le setup afin de préparer l’impulsion.

void setup() {
   pinMode(TRIGGER, OUTPUT);
   digitalWrite(TRIGGER, LOW); //La broche TRIGGER doit être à LOW au repos
   pinMode(ECHO, INPUT);
   Serial.begin(9600);
 }

Nous envoyons ensuite de façon continue des impulsions pour savoir si un obstacle est présent puis, s’il y en a un, nous envoyons un Message Callback.

void loop() {    
    /* 1. Lance une mesure de distance en envoyant une impulsion HIGH de 10 µs sur la broche TRIGGER */
   digitalWrite(TRIGGER, HIGH);
   delayMicroseconds(10);
   digitalWrite(TRIGGER, LOW);
   
   /* 2. Mesure le temps entre l'envoi de l'impulsion ultrasonore et son écho (s'il existe) */
   long measure = pulseIn(ECHO, HIGH);                
                                                                                 
   /* 3. Calcul la distance à partir du temps mesuré */
   long distanceMeasured = measure *vitesse ;
  
   /* 4. Envoie d'un MessageCallback à Constellation si on rentre dans le if */ 
   if(distanceMeasured < defaultValue){
     constellation.sendMessage(Package, "Brain", "message");
   }
}

Etape 2 : Gérer les accès à la boîte aux lettres grâce à un lecteur de carte NFC

Dans cette partie, nous allons envoyer un Message Callback à Constellation grâce à l’ID du badge NFC détecté par notre lecteur de cartes.

Cela nous permettra par la suite de gérer les autorisations d’accès à la boîte aux lettres, de contrôler l’ouverture par notre servo-moteur, et d’avertir l’utilisateur qu’un colis a été livré ou que le courrier a été récupéré. Nous devrons donc enregistrer les différents utilisateurs en renseignant leur ID de badge et leur statut (facteur ou utilisateur).

Voici le câblage réalisé pour cette partie entre le NFC et l’ESP :

Il faut commencer par télécharger la bibliothèque suivante :

Voici ensuite la fonction nécessaire à l’envoi d’un Message Callback lorsque nous captons un nouveau badge.

void NFC() {
    // Regarde s'il y a une nouvelle carte, s'il n'y en a pas on quitte la fonction
    if ( ! mfrc522.PICC_IsNewCardPresent()) {
        return;
    }
    // S'il n'arrive pas à lire la carte on quitte la fonction
    if ( ! mfrc522.PICC_ReadCardSerial()) {
        return;
    }
    char sochar[256]; // 256 correspond à un octet
    String UID= dump_byte_array(mfrc522.uid.uidByte, mfrc522.uid.size); 
    /* Permet de transformer un tableau de bit en String */
    UID.toCharArray(sochar, 256);
    constellation.sendMessage(Package, "Brain", "Authorisation", sochar); /* envoie un message Callback du package Brain appelé Authorisation*/
}

Etape 3 : Ouvrir et fermer la porte grâce à un servo-moteur

Le servomoteur va nous servir à commander notre verrou. Ce dernier va donc s’abonner à un State Object nous donnant l’état de la porte (verrouillée ou déverrouillée). Ainsi, lorsque notre lecteur NFC captera un ID autorisé, notre State Object changera, ainsi que l’état de verrouillage de la porte.

Voici les branchements qui relient notre moteur à l’ESP :

Avant d’utiliser le code ci-dessous, il faut vérifier que vous avez bien installé les bibliothèques suivantes :

Dans le Setup ci-dessous, nous nous abonnons à un StateObject qui nous permet d’ouvrir et de fermer la porte lorsqu’il change d’état.

void setup() {
    monServo.attach(15); // Définit le moteur au D8
    monServo.write(0); // ServoMoteur à sa position initiale
    constellation.registerStateObjectLink("*", "Brain", "Porte_ouverte", [](JsonObject& so) {
     delay(100); // délai afin d'attendre la connexion à  Constellation
     if (so["Value"]== true){   
       monServo.write(90);  // Position de la porte ouverte
       }
 
    if (so["Value"]== false){
       monServo.write(0);   // Position de la porte fermée
       }
       delay(3000); // attendre au minimum 3 secs avant que la porte ne change d'état.
   });  
 }

Etape 4 : Synchroniser toutes nos parties avec un package Constellation

Vous pouvez retrouver notre code complet pour la boîte aux lettres sur GitHub pour plus de précision (https://github.com/Sqyluck/Boite-aux-lettres-connectee).

Il est ensuite nécessaire de créer un package Constellation, qui va nous permettre de traiter toutes les données de nos différents éléments.

→ Voici les différents Message Callbacks créent dans le package afin de répondre à nos besoins.

→ Voici la liste des State Objects générés par le package pour permettre l’affichage de nos données dans l’application et l’envoi d’ordre au servomoteur via l’ESP8266.

Etape 5 : Fabrication de la boîte aux lettres

Nous avons utilisé des planches en bois afin de réaliser notre boîte aux lettres. Nous avons vissé les planches entre elles, puis nous avons fixé nos éléments sous le toit de la boîte.

L’interface utilisateur

Prérequis : disposer de Node.js et de npm

Etape 1 : Créer une application avec ionic

Afin de réaliser notre interface utilisateur, nous avons décidé dans un premier temps de développer notre application avec Ionic 2 dans Visual Studio. Mais avec cette méthode nous étions obligé de développer notre application en langage typescript ce qui était plus compliqué pour connecter l’application à la plateforme Constellation. Nous avons donc décidé d’utiliser Ionic 1 afin de développer notre application en javascript et de la connecter plus facilement.

Avant de commencer, il faut lancer l’installation de Ionic 1 depuis l’invite de commande :

npm install – g cordova ionic

(Attention : cette commande ne fonctionnera pas si vous ne disposez pas auparavant de node.js et de npm)

Une fois que nous nous sommes placé dans le dossier dans lequel nous souhaitons développer notre application, nous pouvons utiliser la commande suivante pour lancer la création d’un nouveau projet.

ionic start myApp tabs --type ionic1

(Nous venons ici de créer un nouveau projet ionic 1 de type tabs intitulé myApp)

Dans l’invite de commande, placez-vous dans le dossier de l’application (en utilisant la commande cd).

La commande ionic serve permet d’exécuter l’application dans un navigateur.

Lorsque le projet est créé, vous devez éditer vos différentes pages (par ex. sur Notepad++). Les fichiers à modifier se trouvent dans le dossier « www » :

• Le fichier index.html
• Les fichiers .html appartenant au dossier “templates” → C’est ici que vous pouvez modifier le contenu de chaque page de votre application.
• Le fichier app.js dans le dossier “js” → Vous devez définir votre constellation à cet endroit.
• Le fichier controllers.js dans le dossier “js” → Chaque controller est associé à une page html. Vous pouvez utiliser les variables et les fonctions définies dans ces pages grâce aux “Scopes”.

Etape 2 : Visualiser notre application sur un smartphone

Si vous souhaitez utiliser votre application sur votre smartphone, vous pouvez utiliser l’application “ionic view” disponible sur l’App Store et Google Play. Cette application vous permettra de visualiser directement l’application que vous êtes en train de développer sur votre smartphone.

Une fois l’application installée, vous devez ensuite vous rendre sur ce site, créer un compte, puis cliquez sur “New App”. Il ne vous reste plus qu’à faire le lien avec votre application et l’envoyer sur votre appareil. Pour cela, dans le dossier de votre application, utilisez les deux commandes suivantes dans votre invite de commande

ionic link 
ionic upload

Ouvrez ensuite ionic view et visualisez votre application.

Vous pouvez également, après avoir branché votre téléphone et avoir activé le mode debug, utiliser la commande cordova run android afin de simuler directement votre application sur votre téléphone android.

Etape 3 : Connecter notre application à constellation

Afin de connecter notre application à la plateforme constellation, nous allons modifier le fichier app.js ainsi que le index.html.

Pour cela, nous allons importer les bibliothèques suivantes dans le fichier index.html :

• jquery-2.2.4.min.js
• jquery.signalr-2.2.1.min.js
• Constellation-1.8.1.min.js
• ngConstellation-1.8.1.min.js

Les librairies sont disponibles sur cette page. Nous vous conseillons de créer un dossier intitulé constellation dans le dossier « lib » et d’y enregistrer ces différentes bibliothèques.

Il ne vous restera plus qu’à ajouter les lignes de code suivantes dans le fichier index.html :

<script type="text/javascript" src="lib/constellation/jquery-2.2.4.min.js"></script>
<script type="text/javascript" src="lib/constellation/jquery.signalr-2.2.1.min.js"></script>
<script type="text/javascript" src="lib/constellation/Constellation-1.8.1.min.js"></script>
<script type="text/javascript" src="lib/constellation/ngConstellation-1.8.1.min.js"></script>

Puis nous allons ajouter le code suivant à notre fichier app.js :

1. Modifier la ligne angular.module, y ajouter ‘ngConstellation’ comme ci-dessous :

angular.module('starter', ['ionic', 'starter.controllers', 'ngConstellation'])

2. Modifier la fonction .run, y ajouter $rootScope et constellationConsumer :

.run(function($ionicPlatform, $rootScope, constellationConsumer)

3. Ajouter le code suivant dans la fonction .run :

constellationConsumer.initializeClient("http://192.168.43.171:8088", "123456789", "Application Ionic");
    constellationConsumer.onConnectionStateChanged(function (change) {
        if (change.newState === $.signalR.connectionState.connected) {
            console.log("Connecté à constellation");
            $rootScope.isConnected = true;
        }
    });
    constellationConsumer.connect();
    $rootScope.constellation = constellationConsumer;

Vous pouvez maintenant vérifier que vous êtes bien connecté à votre constellation en regardant dans votre console (f12 dans votre navigateur).

Etape 4 : Connecter notre application à la boîte aux lettres

Un certain nombre de State Objects et de Message Callbacks ont été réalisés dans notre package constellation afin de traiter nos différentes informations (ce package est disponible sur gitHub).

Le rôle de notre application ici est simplement de s’abonner aux State Objects et d’envoyer des messages Callbacks à notre constellation.

→ Exemple de récupération d’un State Object :

Les StateObjects se récupèrent dans le fichier app.js, à l’endroit où nous avons défini notre constellation. Voici un exemple de code correspondant à notre State Object « Users » :

//State Object Utilisateurs
constellationConsumer.registerStateObjectLink("*", "Brain", "Users", "*", function(so) {
    $rootScope.Users = so.Value;
    $rootScope.$apply();
});

Pour afficher nos utlisateurs, il nous suffit maintenant, dans notre page html d’utiliser le code suivant :

<ion-item ng-repeat="user in Users">
  <h2>{{user.firstName}} {{user.name}}</h2>
  <p>{{user.client ? "client":"facteur"}}</p>
</ion-item>

→ Exemple d’envoi d’un message Callback :

Les messages Callbacks s’envoient dans le fichier controllers.js. Voici l’exemple de code pour le Message Callback « DeleteUser » :

//Message CallBack DeleteUser
$scope.name = $stateParams.name
$scope.firstName = $stateParams.firstName;
$scope.deleteUser = function() {
    var deleteUser = $ionicPopup.confirm({
      title: 'Supprimer cet utilisateur',
      template: 'Etes vous sur de vouloir supprimer cet utilisateur ?'
    });
    deleteUser.then(function(res) {
      if(res) {
          $rootScope.constellation.sendMessage({ Scope: 'Package', Args: ['Brain'] }, 'DeleteUser', [$scope.firstName, $scope.name ]);
          $state.go('tab.utilisateurs');
          console.log('deleted');
      } 
      else {
          console.log('do nothing');
      }
    });
};

Dans notre page html, on appelle maintenant la fonction créée dans notre controller.js dans un bouton par exemple :

<button ng-click="deleteUser()">Supprimer cet utilisateur</button>

En vous servant de cette base, vous pouvez réaliser une application vous permettant de recevoir un message sur votre application lorsque vous recevez un courrier ou un colis mais aussi d’ajouter ou de supprimer des accès à la boite aux lettres.

Il est également possible de réutiliser des packages existants, par exemple, nous nous sommes servis du package PushBullet afin de recevoir des notifications sur notre smartphone.

Voici un aperçu de notre application ionic :

The post Créer une boite aux lettres connectée avec 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.