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.

Introduction

Nous sommes 5 étudiants en troisième année de Cycle Informatique et Réseaux à l’ISEN et nous avons conçu un nouveau concept de solution fitness basée sur un miroir. Pour réaliser notre projet, nous avions un budget de 0€ mais nous avions surtout une grande motivation pour créer un produit innovant et agréable à utiliser.

C’est pour cela que nous avons utilisé des produits de récupérations. En effet, nous avons tous dans notre garage un ordinateur portable que nous n’utilisons plus, une ancienne webcam, et quelques planches de contreplaqué. Concernant l’aspect miroir, nous avons utilisé du film sans tain car nous en avions déjà, cependant, pour une dizaine d’euros de plus, vous pourrez utiliser une vitre sans tain. Cette dernière donnera un rendu bien meilleur à votre miroir. Voilà qui devrait suffire pour la partie matérielle de notre projet.

Pour la partie logicielle, nous avons utilisé la plateforme Constellation. Les lecteurs réguliers de ce magazine la connaissent déjà, pour les autres, il s’agit d’une plateforme technique d’orchestration et d’interconnexion des objets, des services et des applications. Elle s’appuie sur des paquets qui peuvent publier et consommer des messages ainsi que sur des fonctions partagées. Concrètement, avec Constellation, en quelques lignes, il devient très simple de connecter des objets (ou applications) entre eux. Ces derniers vont donc dialoguer via Constellation comme le feraient des micro-services. L’avantage d’utiliser cette plateforme pour un tel projet c’est la facilité avec laquelle nous avons pu connecter et déployer les différentes briques de notre miroir. Pour en savoir plus sur cette technologie, vous pouvez vous rendre sur http://www.myconstellation.io/

Pour résumer, en raison d’un coût très faible et d’un développement simplifié, S-Fit est le projet parfait pour vous occuper cet été.

Fonctionnement général

Nous avons tout d’abord pensé S-Fit comme une application dotée d’un podomètre. Cette dernière synchronise les différents profils des membres de la famille en temps réel grâce à Constellation. Vous pouvez ainsi y gérer vos propres objectifs et surveiller votre progression. Vous ne perdrez pas votre motivation grâce à notre système de trophées qui vous donnera envie de repousser vos limites chaque jour. Comme il n’existe pas de meilleure motivation que la compétition, vous pourrez vous comparer à vos proches grâces à des outils d’analyse s’appuyant sur une série de graphiques.

Pour vous rappeler vos objectifs chaque matin, nous avons ajouté à S-Fit un miroir compagnon. Ce dernier a demandé beaucoup de réflexion car il s’agit d’un nouvel objet avec lequel il faut interagir de manière naturelle. De plus, il fallait faire de ce dernier un bel objet que l’on puisse retrouver chez soi. Nous avons donc fait le choix d’une interface minimaliste qui affiche seulement les informations pertinentes : la météo, les évènements à venir et votre progression. De ce fait, pas besoin de toucher le miroir et d’y laisser des traces de doigts.

Pour gérer les multiples profils, nous avons également intégré un module de reconnaissance faciale qui permettra au miroir d’afficher des informations personnalisées en fonction de son utilisateur.

Comme vous vous en doutez surement, le lien entre l’application et le miroir se fait par l’intermédiaire de la plateforme Constellation. Tout est synchronisé en temps réel et cela fonctionne comme par magie.

Etape 1 : Conception du boîtier

Pour commencer, il faut démonter votre vieil ordinateur, afin d’en récupérer la dalle LCD. On utilise ensuite la référence de cette dernière pour pouvoir se procurer le contrôleur adapté.

Ensuite, il faut concevoir un boîtier capable d’accueillir l’ensemble de votre appareil. Son épaisseur et ses dimensions dépendent donc de votre miroir. Nous ne fournirons donc pas de plans pour rendre votre création unique.

Attention toutefois à prévoir des espaces pour l’aération, l’alimentation et les contrôles de la dalle.

C’est la partie la plus personnelle du projet, c’est le moment de libérer votre créativité pour mettre en place votre vision de S-Fit.

Nous avons également prévu une trappe d’accès à l’arrière pour pouvoir modifier notre miroir plus tard.

Si vous avez fait le choix du film sans tain, il va falloir le poser. Pour cela, voici les quelques étapes à suivre :

• Nettoyer votre dalle à l’aide d’un chiffon doux
• Appliquer un peu d’eau savonneuse sur celle-ci
• Poser le film sans tain petit à petit en vous aidant d’un grattoir. Attention à ne pas rayer le film avec, c’est très fragile !
• Chassez, toujours avec ce grattoir, les dernières bulles d’air

Prenez bien votre temps lors de la pose, c’est une partie très délicate et elle affectera directement l’esthétique de votre miroir.

Vous avez maintenant l’ensemble des pièces qui vont constituer votre miroir. Pour terminer, il ne vous reste plus qu’à tout assembler en faisant attention à bien aligner la dalle et le boîtier.

Si vous souhaitez intégrer un module de reconnaissance faciale, il va falloir ajouter une webcam (USB).

Pour cela, il faut la démonter, récupérer le circuit et le fixer dans le boîtier.

Etape 2 : Le développement logiciel

Etape 2.1 : L’interface du miroir

Pour réaliser le miroir, nous avons choisi de concevoir une application web avec AngularJS. En effet, comme le dit le créateur de Constellation, Sébastien Warin, on peut connecter n’importe quoi avec quelques lignes de code qui vont bien.

Tout d’abord, il est important de rappeler que pour continuer ce tutoriel, il est nécessaire d’avoir une Constellation déployée chez soi. Vous trouverez la plateforme ainsi que les tutoriels de prise en main sur le portail https://developer.myconstellation.io/

Nous allons donc pouvoir connecter notre application Angular à Constellation :

var app = angular.module('Mirror', ['ngConstellation']);

app.controller('MyController', ['$scope', 'constellationConsumer', ($scope, constellation) => {

    constellation.initializeClient("maconstellation.local", "masupercle123", "MyMirror");

    constellation.connect();

}]);

Il ne reste plus qu’à s’abonner aux StateObjects de Constellation que l’on veut voir sur le miroir. Par exemple, ici, nous allons récupérer la météo dans la ville de Lille :

constellation.registerStateObjectLink("*", "ForecastIO", "Lille", "*", (so) => {
    $scope.$apply(() => {
        $scope.temperature = so.Value.currently.temperature;
    });
});

Pour en savoir plus, vous pouvez vous rendre sur le portail dont le lien se trouve plus haut pour y trouver la documentation complète. Vous trouverez d’ailleurs un tutoriel détaillé sur l’utilisation de Constellation en JavaScript. Mais rassurez vous, ce n’est pas plus compliqué que cela. Il ne manque que quelques lignes d’HTML et de CSS pour donner vie à votre miroir.

Si on continue l’exemple de la météo, le code HTML associé pourrait-être le suivant :

<p>{{temperature}}</p>

On obtiendrait alors une page sur laquelle la température va s’afficher dynamiquement.

Etape 2.2 : La reconnaissance faciale

Comme nous l’expliquions plus haut, nous avons ajouté un module de reconnaissance faciale pour gérer plusieurs profils. Il s’agit d’une partie facultative et plutôt complexe.

Pour cela, nous avons utilisé une application open source existante qui s’appuie sur EMGU.CV. C’est un portage en C# d’OpenCV. Malheureusement, cette application était trop ancienne et nous n’avons pas réussi à la connecter directement à Constellation. Pour résoudre ce problème, nous avons conçu un paquet Constellation qui permet de publier et de s’abonner aux StateObjects par l’intermédiaire de sockets TCP.

Lors de l’ajout d’un nouvel utilisateur S-Fit, le paquet lance la séquence d’enregistrement d’un visage automatiquement.

Nous avons effectué plusieurs essais sur la quantité d’images à enregistrer, afin d’obtenir l’équilibre idéal entre une reconnaissance optimale et un minimum d’espace utilisé. Pour vous reconnaître, l’algorithme s’appuie sur plusieurs caractéristiques faciales, comme la forme du nez, de la bouche, des yeux, de vos sourcils…

De par le peu d’espace pris par la reconnaissance, vous pouvez aisément enregistrer toute votre famille, afin que le miroir devienne un élément à part entière de votre lieu de vie, et que tout le monde participe à la compétition !

La reconnaissance faciale se déroule en deux étapes. La première consiste à détecter un visage. Pour cela nous avons utilisé le classificateur Haar car il nous fallait une reconnaissance faciale en temps réel. Le classificateur Haar est, en fait, un fichier xml contenant une quantité énorme de photos dites négatives et positives. Les photos positives contiennent un visage, tandis que les photos négatives n’en contiennent pas. Cela permet donc de savoir si un visage est présent sur une photo ne faisant pas partie du classificateur. À noter qu’il est possible de créer soi-même son propre classificateur ou même d’en améliorer un.

Ici, nous nous servons donc de ce dernier afin de vérifier si, sur la frame actuelle, un visage est présent ou non de la sorte :

gray_frame = currentFrame.Convert<Gray, Byte>();

MCvAvgComp[][] facesDetected = gray_frame.DetectHaarCascade(Face, 1.2, 10, Emgu.CV.CvEnum.HAAR_DETECTION_TYPE.DO_CANNY_PRUNING, new Size(50, 50));

Ceci va donc insérer dans le tableau facesDetected[0] tous les visages ayant eu un résultat positif après comparaison avec le classificateur Haar.

Dans un second temps, on cherche à reconnaître une personne à l’aide de son visage, l’application dispose donc d’une architecture très simple divisée en trois classes C#. La classe principale va capturer le flux vidéo de la webcam puis par la suite analyser chaque image via la classe de reconnaissance de personne qui, elle, aura au préalable chargé les données des personnes déjà enregistrées. La dernière classe sert, quant à elle, à enregistrer une personne en prenant une centaine de photos du visage de celle-ci.

Pour communiquer avec notre package, nous avons également ajouté une classe TCPClient.cs qui se connecte et échange les StateObjects via le réseau.

C’est d’ailleurs les paquets reçus qui vont démarrer les fonctions d’ajout d’utilisateur.

Pour rendre la gestion des utilisateurs agréable, nous avons intégré cette reconnaissance faciale de manière totalement transparente. Lorsqu’un utilisateur s’enregistre dans l’application il doit être face au miroir. Pour vérifier cela, l’utilisateur sera invité à saisir un code à six chiffres qui s’affichera quelques secondes sur le miroir. Une fois l’ensemble des informations saisies dans l’application, le miroir va automatiquement lancer une séquence de capture de 100 clichés du nouvel utilisateur.

Pour la reconnaissance des utilisateurs enregistrés, le paquet de reconnaissance faciale va capturer une image chaque seconde pour vérifier la présence ou non d’un individu connu.

Lorsque deux utilisateurs enregistrés sont face au miroir, ce dernier va se concentrer sur celui qu’il identifie le mieux.

Etape 2.3 : L’application mobile

L’application S-Fit a été conçue avec les frameworks Ionic 3 et Apache Cordova. Ces frameworks permettent d’obtenir une application Web à l’intérieur d’une application native Android ou iOS qui embarque un serveur NodeJS sur le mobile. Comme nous l’avons vu plus haut, l’application qu’affiche le miroir est une page web, l’application mobile utilise donc les mêmes technologies.

Ainsi, la connexion s’effectuera tout aussi simplement :

var constellation = $.signalR.createConstellationConsumer("maconstellation.local", "masupercle123", "MonApp");

constellation.connection.start();

Une application comme la nôtre peut alors consommer des StateObjects mais également envoyer des MessageCallbacks. C’est à dire exécuter des fonctions directement sur la Constellation. C’est particulièrement utile pour incrémenter le compteur de pas.

Nous avons découpé notre application en trois grandes parties : la gestion des profils, les activités et les trophées.

Gestion des profils

Comme S-Fit est pensé pour plusieurs utilisateurs, nous avons géré les profils dans notre application.

Lorsqu’un utilisateur lance l’application, il peut choisir son profil. Cette action va établir la connexion avec la Constellation pour récupérer les informations personnelles et l’historique d’activités. Toutefois, s’il n’a pas de profil, il peut en ajouter un s’il est en face du miroir, qui lui affichera alors un code de vérification. Lors du lancement de l’application, cette dernière synchronise instantanément les nouvelles données d’activités avec le serveur Constellation.

L’utilisation d’S-Fit est totalement transparente et ne demande pas de manipulation particulière de l’utilisateur. En effet, nous avons cherché à fournir un produit simple, accessible et entièrement automatisé. Cette synchronisation est permise par Constellation.

Les activités

Cette partie se compose d’un podomètre, d’un récapitulatif de la journée en cours et d’un historique sous forme de graphiques.

Pour le podomètre, nous nous sommes appuyés sur un plugin de Cordova permettant d’accéder aux données de l’accéléromètre du mobile. A l’aide des données fournies par ce plugin, nous avons pu étudier les variations sur les axes x, y et z, dans l’optique de compter les pas.

L’application récupère donc les données accélérométriques de votre mobile toutes les 0.120 secondes. C’est une valeur que nous avons retenue après plusieurs jours de tests pour affiner la précision du compteur de pas, puis, en s’appuyant sur les précédentes valeurs, on va déterminer si le mouvement effectué est un pas ou non, et donc informer Constellation si elle doit incrémenter le nombre de pas de l’utilisateur.

Le développement de cette application ne se résume pas qu’à de la programmation informatique. Nous avons également réalisé des mesures sur plusieurs dizaines de personnes afin d’obtenir un lien entre la morphologie et la longueur des pas

var slope = 0.64878048 ;
var origin = 44.6744 ;

function getDistance(size, stepCounter) {
    return (size * slope - origin) * stepCounter;
}

Avec les informations physiologiques et l’activité de l’utilisateur, on peut donc créer un ensemble de fonctions qui permettent d’étudier son état de santé, en calculant par exemple les calories dépensées chaque jour. C’est grâce à ces données qu’il est possible de créer une application fitness entièrement maîtrisée. On est alors libre d’appliquer les algorithmes souhaités sur les données récupérées.

Pour la page des graphiques sur l’application mobile, nous avons utilisé la bibliothèque Chart.js qui permet de tracer des graphiques dynamiques avec un rendu épuré. Son principal avantage est la prise en main rapide de la bibliothèque ainsi que toutes ses options.

Voici un exemple pour tracer un graphique linéaire

var myLineChart = new Chart(ctx, {
    type: 'line',
    data: data,
    options: options
});

Cependant, il faut tout d’abord récupérer les informations présentes dans les StateObjects pour les afficher dans les graphiques. Cela nous permet de faire des graphes qui se mettent à jour en temps réel.

Les trophées

Comme nous l’expliquions plus haut, nous avons intégré un système de trophées et de récompense. Il se présente tout d’abord comme une liste de trophées que l’on débloque en réalisant des succès particuliers (pas, distance).

Les trophées montrent votre expérience sur S-Fit, et représentent donc la récompense pour vos efforts. Lorsque l’on clique sur un trophée débloqué, on affiche son détail et le nombre de points qu’il a rapporté.

Conclusion

Voilà qui conclue les grandes étapes de la réalisation de S-Fit. Comme vous avez pu le voir les possibilités de personnalisation sont très nombreuses. C’est un projet ludique et facile à réaliser. 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 version.

Nous tenons également à remercier Julie, Adrien et tous ceux qui se sont impliqués de près ou de loin dans la réalisation de ce projet.

Auteurs : Valentin BEQUART, David BRICENO-AGUILERA, Pierre-Alexandre CHOAIN, Milan FERTIN et Hugo MROCZKOWSKI.

The post S-Fit : Concevez un miroir connecté orienté fitness appeared first on Constellation.

Introduction

Nous sommes quatre étudiants en Master 2 à l’ISEN Lille. Nous nous sommes récemment découverts une passion pour les fléchettes, surement lié à la présence d’une cible dans le bar que nous fréquentons (avec modération) après les cours.

La découverte de cette nouvelle passion nous a poussé à ressortir du placard les cibles avec lesquelles nous avons pu jouer étant plus jeunes. Mais le plaisir de jouer aux fléchettes n’était pas le même. C’est vrai que l’écran LCD de 2cm par 4cm et le haut parleur 8-bit n’offre pas la même ambiance que celle que nous pouvons avoir sur une borne de bistrot.

Il existe de nombreux tutoriel pour se créer une borne d’arcade chez soi pour les fans de rétro-gaming mais nous n’avons rien trouvé pour “pimper” notre jeu de fléchettes, mis à part un article de blog qui sans expliquer les détails de la transformation nous a servie de “Preuve de faisabilité”.

Mais nous avons décidé d’aller un peu plus loin que de simplement améliorer l’expérience utilisateur en optimisant l’affichage ainsi que les effets sonores. Afin d’intégrer la cible comme un objet connecté à part entière, Constellation a été utilisé

Connecter la cible

Côté matériel la première étape est de faire l’acquisition d’une cible électronique (bas de gammes afin de limiter les coûts), nous avons choisis le jeu de fléchette le moins chère que l’on ai pu trouver : 19,99 euros.

La détection d’une fléchette par la cible se fait à l’aide de 2 nappes en plastiques séparées par une épaisseur en mousse trouée.

On remarque que le jeu est divisé en 2 moitiés (Par l’axe qui passe entre la zone 9 et 14) l’une des 2 nappes en plastique contient 7 pistes conductrices:

• une pour toutes les zones “Simple” de la moitié de la cible
• une pour toutes les zones “Simple” de l’autre moitié de la cible
• une pour toutes les zones “Double” de la moitié de la cible
• une pour toutes les zones “Double” de l’autre moitié de la cible
• une pour toutes les zones “Triple” de la moitié de la cible
• une pour toutes les zones “Triple” de l’autre moitié de la cible
• une pour le “Bull” Simple et Double

L’autre nappe contient 10 pistes, 8 des pistes correspondent chacune à une paire de zone numérotée, chacune des zones appartenant à une moitié différente ((9, 14) par exemple). Les 2 pistes restantes ont, en plus de la paire de zone, une zone du “Bull”.

On se retrouve donc avec ce tableau qui permet de déterminer quelle zone a été touchée. Il suffit d’alimenter les 7 pistes “OUT” une par une et de lire l’état des 10 pistes “IN”. Si on voit que l’une des pistes IN est alimenté alors on peut en déduire la zone touchée.

Maintenant que l’on sait comment ça marche, il ne reste plus qu’à le connecter aux GPIO du microcontrôleur de son choix.

Dans ce tutoriel nous avons choisi de connecter la cible à un Raspberry Pi B+ mais il est tout à fait possible de le faire avec un Arduino, un ESP8226 ou encore un autre type de Pi. La seule contrainte est qu’il faut au moins 17 GPIO, il faudra donc augmenter le nombre de GPIO à l’aide d’un MCP23017-E/SP 16 I/O Expander.

Il faudra aussi que soit installé sur le device une sentinelle constellation.

Les nappes étant en plastique on ne peut venir souder dessus, on choisit donc de venir souder les fils sur le circuit imprimé directement, ensuite on peut remonter le tout. Et pour tester on les relies au Pi à l’aide d’une plaque de test (BreadBoard).

On peut maintenant déployer un package sur le pi pour connecter notre cible a constellation. Sur Le raspberry Pi, le plus simple est de faire un package python en utilisant la librairie GPIO.

Cette petite fonction va permettre de transformer un couple de GPIOs (entré, sortie), en un message pour constellation contenant une zone de la cible.

def dartTouch(pinin,pinout):
    outputDictionary = {}
    outputDictionary[PIN_TRIPPLE_1] = [3,1]
    outputDictionary[PIN_DOUBLE_1] = [2,1]
    outputDictionary[PIN_SINGLE_1] = [1,1]
    outputDictionary[PIN_BULL] = [0,2]
    outputDictionary[PIN_SINGLE_0] = [1,0]
    outputDictionary[PIN_DOUBLE_0] = [2,0]
    outputDictionary[PIN_TRIPPLE_0] = [3,0]

    inputDictionary = {}
    inputDictionary[PIN_9_14_B] = [9,14,50]
    inputDictionary[PIN_20_16_1] = [20,16,1]
    inputDictionary[PIN_12_11_B] = [12,11,25]
    inputDictionary[PIN_5_8_2] = [5,8,2]
    inputDictionary[PIN_6_2_3] = [6,2,3]
    inputDictionary[PIN_10_15_4] = [10,15,4]
    inputDictionary[PIN_13_17_5] = [13,17,5]
    inputDictionary[PIN_4_3_6] = [4,3,6]
    inputDictionary[PIN_18_19_7] = [18,19,7]
    inputDictionary[PIN_1_7_8] = [1,7,8]


    isButton = False
    value = inputDictionary[pinin][outputDictionary[pinout][1]]
    multiple = outputDictionary[pinout][0]
    if(multiple == 0):
        isButton = True
        multiple = 1
        if(value == 50):
            multiple = 2
            value = 25
            isButton = False
        if(value == 25):
            multiple = 1
            isButton = False
    if isButton :
       Constellation.SendMessage("DartManager", "ButtonPressed",[ value ])
    else:
       Constellation.SendMessage("DartManager", "onDartTargetTouch",[ multiple, value ])
    time.sleep(0.8)

Il ne reste plus qu’à alimenter les pins de sorties une à une et de lire l’état des pins en entrée.

while True:
  for pinout in outs:
    GPIO.output(pinout,GPIO.HIGH)
    for pinin in ins:
      if(GPIO.input(pinin)):
        dartTouch(pinin,pinout)
    GPIO.output(pinout,GPIO.LOW)

Une fois notre prototype avec la BreadBoard testé et approuvé nous avons pus réaliser un deuxième prototype sur lequel nous avons juste à venir brancher les pins de notre pi et de notre cible.

Ce prototype moins encombrant, apporte également plus de robustesse à notre jeu dans l’optique d’une utilisation plus fréquente.

Constellation

Afin de pouvoir envoyer l’information qu’une fléchette a touché la cible, de pouvoir traiter l’information pour par exemple savoir si l’utilisateur en a déjà lancé trois et ainsi que cette dernière ne compte pas, puis afficher cette information sur les différentes interfaces graphiques, nous devions créer un bus de données.

Pour cela, nous avons utilisé le principe des “StateObject” et ”MessageCallBack” de Constellation afin de communiquer entre chacune des différentes parties.

Deux packages Constellation ont donc été créé, l’un en Python, pour la détection des fléchettes et l’autre en C# pour la gestion de parties.

Ainsi lorsque qu’une fléchette touche la cible, le package en Python va envoyer cette information au package C# en appelant la méthode “onDartTargetTouch”,

Constellation.SendMessage("DartManager", "onDartTargetTouch",[ multiple, value ])

qui va, après avoir effectué les modifications engendrées par ce coup sur la partie, mettre à jour le StateObject ‘’DartGame’’ afin que, l’UI qui s’y est abonné, soit informé.

[MessageCallback]
void onDartTargetTouch(short multiple,short value)
{
   PackageHost.WriteInfo(multiple + " "+ value);
   if(game.applyShoot(new Shoot(multiple, value), this)){}
   update();
}

private void update()
{
   PackageHost.PushStateObject<AbstractDartGame>("DartGame", game);
}

Le StateObject “DartGame” représentant la partie actuelle (joueurs, tours, tirs, etc..) sous forme d’un objet JSON.

Le but étant, une fois les paquets installés sur chacune des machines respectives (“sentinelle” pour Constellation), de pouvoir tout contrôler depuis l’UI. Des MessageCallBack sont donc mis à la disposition de cette dernière, représentant ainsi l’ensemble des fonctions nécessaires à la gestion d’une partie.

User Experience

Le gros point noir de notre cible, comme nous l’avons décrit en introduction, était l’interaction avec les utilisateurs et comme vous pouvez vous en douter après les modifications que nous avons apportés à notre cible l’afficheur de score d’origine n’est plus fonctionnel. Pour le remplacer nous avons donc réalisé un Dashboard sous la forme d’une application web.

Le Dashboard

Le Dashboard comme nous l’avons évoqué ci-dessus est une application qui nous permet d’afficher les scores provenant de notre Constellation simplement en s’abonnant au StateObject du manager de jeu. L’interface de ce Dashboard a été réalisé avec AngularJS et Angular Material pour le design. En effet en nous abonnant à un StateObject via Constellation, le Dashboard est notifié de chaque modification apportées à la partie de fléchette en cours et de modifier l’affichage dynamiquement grâce à l’objet JSON fournis par Constellation tout cela en simplement quelques lignes de codes :

constellation.registerStateObjectLink("*", "*", "DartGame", "*", function (so) {
    $scope.$apply(function() {
       $scope.constelationGame = so.Value;
    });           
});

La connection du Dahboard à Constellation permet également d’exposer des méthodes afin de déclencher des effets sonores sur certains lancers afin de dynamiser la partie.

constellation.subscribeMessages("DartsDashboard");
constellation.registerMessageCallback("Triple", function (msg) {
    var audio = new Audio('sounds/Triple.wav');
    audio.play();
});
                
constellation.registerMessageCallback("Double", function (msg) {
    var audio = new Audio('sounds/Double.wav');
    audio.play();
});

Pour le design, Angular Material nous a permis de développer rapidement et simplement une interface esthétique.

L’application mobile

Toujours dans le but d’améliorer les fonctionnalités offertes par notre jeu customisé, une application mobile accompagne notre nouvel objet connecté pour y ajouter une dimension sociale ! Baptisé My Dart Compagnon, elle se destine aux joueurs les plus passionnés.

L’application est réalisée avec Ionic, un Framework open source qui permet de développer des applications mobiles hybrides rapidement et facilement. Il s’appuie sur AngularJS pour la partie application web du framework et sur Cordova pour la partie construction des applications natives. On peut donc très facilement se connecter à Constellation via le SDK JavaScript. Ionic framework permet de développer une seule application et de la déployer sur tous les supports, web ou mobile, que ce soit Android, iOS ou bien Windows Mobile.

De plus, l’application intègre les services Firebase, la plateforme d’outils mobile de Google qui permet d’implémenter un espace de stockage synchronisé et personnel pour l’utilisateur en toute simplicité, en mode cloud. Cet espace peut être accessible par d’autres clients, comme par exemple le Dashboard.

En utilisant l’authentification Facebook, l’application permet de voir ses amis qui l’utilisent également et de les inviter à jouer. Au début de chaque partie, le joueur peut charger son profil sur le Dashboard présenté ci-dessus en flashant un QR Code. Cela lui permet de suivre son score personnel durant la partie sur son smartphone, de consulter l’historique de ses parties disputées et ses statistiques personnelles. Les joueurs les plus compétiteurs chercheront eux à débloquer l’intégralité des succès : des récompenses débloquées lors de la réalisation de certaines actions ou performances.

The post Jeu de fléchettes connecté à Constellation appeared first on Constellation.

Dans cet article, nous allons nous intéresser à l’ajout d’un périphérique ultime puisqu’il s’agit de l’interaction avec la voiture électrique de la marque Tesla, la Model S et d’un ensemble de différents capteurs déjà présents dans la constellation.

Créer un package Tesla pour Constellation

Découverte de l’API non-officielle de Tesla

La Tesla Model S est en permanence connectée via une connexion 3G intégrée qui communique avec les serveurs de Tesla leur permettant de récupérer des informations de diagnostic sur le véhicule mais aussi de délivrer des mises à jour « over the air » et d’apporter des fonctionnalités d’interaction avec le véhicule depuis l’application officielle disponible pour iOS et Android.

Certains développeurs ont donc cherché à comprendre comment ces applications interagissent avec l’infrastructure de Tesla pour piloter un ensemble de fonctionnalités de la voiture ou pour récupérer les informations sur la voiture et ils sont arrivés à fournir une spécification relativement exhaustive qui a permis le développement d’applications tierces (mobiles ou statistiques).

Il est à noter que cette interface peut tout à fait changer en fonction des choix faits par Tesla néanmoins nous allons explorer quelques fonctionnalités et préciser comment il est possible d’interagir avec le véhicule et le reste des équipements connectés à la Constellation.

Pour la sécurité, elle repose sur la mise en œuvre d’un protocole OAuth 2.0 classique dont il faut ensuite transporter le jeton en entête des requêtes ensuite transmises.

L’API gère plusieurs véhicules associés au même utilisateur, il est donc tout à fait possible de gérer plusieurs Tesla et pour les lister nous utiliserons la méthode dédiée (GET) :

https://owner-api.teslamotors.com/api/1/vehicles

L’API propose des fonctionnalités pour récupérer des informations sur le véhicule mais également pour exécuter des commandes qui peuvent agir sur la voiture. Voici un schéma présentant les fonctionnalités proposées :

Intégration dans un package Constellation

En utilisant le SDK de Constellation directement intégré à Visual Studio, la création d’un package est simplifié et la réalisation du package dédié à Tesla se fait directement en utilisant le Framework .Net et en utilisant le langage C#. On commence par créer une application console en prenant soin d’intégrer l’API Tesla, nous créons une tache en background pour venir régulièrement interroger l’état de la voiture :

Task.Factory.StartNew(
    async () =>
    {
        while (PackageHost.IsRunning)
        {
            // Get every information about the car
            this.GetDrivingInformation();
            this.GetChargeInformation();
            this.GetClimateInformation();
            this.GetVehicleInformation();

            await Task.Delay(PackageHost.GetSettingValue<int>("RefreshInterval"));
        }
    });

Par exemple, la méthode « GetClimateInformation » invoque la méthode REST suivante :

https://owner-api.teslamotors.com/api/1/vehicles/{vehicle_id}/data_request/climate_state

Les données remontées nous permettent de récupérer l’état de la climatisation ainsi que les températures à l’intérieur du véhicule :

{
  "response": {
    "inside_temp": 17.0,            // Température en degrés Celsius (°C) intérieur
    "outside_temp": 9.5,            // Peut être null quand pas initialisé
    "driver_temp_setting": 22.6,    // Consigne côté chauffeur (°C)
    "passenger_temp_setting": 22.6,     // Consigne côté passager (°C)
    "is_auto_conditioning_on": false,   // Fonctionnalité en Beta pour chauffage auto
    "is_front_defroster_on": null,  // Dégivrage avant
    "is_rear_defroster_on": false,  // Dégivrage arrière
    "fan_status": 0                 // Vitesse de la ventilation
  }
}

Une fois les données désérialisées dans un objet .NET, il suffit simplement de le publier dans la Constellation en tant que StateObject grâce à la méthode « PushStateObject ».

Par exemple, lorsque nous récupérons l’état de la climatisation (classe ClimateInformation), nous remontons cet objet au niveau Constellation avec la ligne :

PackageHost.PushStateObject<ClimateInformation>("Tesla.Climate", informations,
       new Dictionary<string, object>
           {
                { "TimeStamp", DateTime.UtcNow.ToUnixTimestamp() },
                { "VehicleId", vehicleId }
           });

Ainsi notre package remonte actuellement quatre StateObjects dans Constellation à intervalle régulier :

• Tesla.Charge : informations quant à la batterie (méthode REST « charge_state »)
• Tesla.Climate : informations quant à la climatisation (méthode REST « climate_state»)
• Tesla.Drive : informations quant à la position et le déplacement de la voiture (méthode REST « drive_state»)
• Tesla.State : informations quant à l’état de la voiture (méthode REST « vehicle_state»)

Vous pouvez explorer et visualiser vos StateObjects depuis la console Console. Par exemple, si nous ouvrons le StateObject «Tesla.Climate », nous retrouvons toutes les informations fournies par l’API Tesla :

Dès lors, n’importe quel système connecté à Constellation, que ce soit le type d’application, peut connaitre en temps réel l’état de ma voiture, de la climatisation, la batterie, etc… Le package réalisé a donc la responsabilité d’interroger régulièrement l’API de Tesla pour mettre à jour les StateObjects dans la Constellation et donc agir tel un « connecteur » faisant le lien entre l’API Tesla et le monde Constellation.

Au-delà des StateObjects, un package Constellation peut également exposer des actions, c’est ce qu’on appelle des « MessageCallbacks ». En .NET, il suffit d’ajouter l’attribut « MessageCallback » pour exposer une méthode dans Constellation comme suit :

[MessageCallback]
public bool CommandFlashLight(string vehicleId)
{
    bool result = false;

    if (this.VehicleConfigurations.FirstOrDefault(c => c.Id == vehicleId) != null)
    {
        result = new VehicleCommandConnector(this.AuthenticationInformation, vehicleId).Flash();

        PackageHost.WriteInfo("Tesla Package - Command - Flash lights invoked");
    }

    return result;
}

Concrètement, la méthode « Flash() » invoquera la méthode http/REST « flash_lights » avec l’URL suivante :

https://owner-api.teslamotors.com/api/1/vehicles/{vehicle_id}/command/flash_lights

Tout comme les StateObjects, il est possible d’explorer les MessageCallbacks de chaque package de la Constellation depuis la Console. Ici notre package Tesla expose plusieurs méthodes invocables depuis tous les autres packages selon les paramètres de sécurité établis. Ces méthodes permettent de récupérer des informations sur le véhicules (charge, position, climatisation) ou de contrôler la voiture comme faire des appels de phare, klaxonner, ouvrir le toit ouvrant, régler la climatisation…

Scénario 1 – Pilotage en fonction de la météo

De manière logique et simple, lorsque les conditions météos ne sont pas optimales et que le véhicule est resté ouvert, un module de supervision et d’intelligence ambiante provoque la fermeture du toit ouvrant ou signale à son utilisateur qu’une porte est restée ouverte.

Pour cela nous utilisons la station météo Netatmo installée chez moi et qui est composée de plusieurs modules ayant des rôles distincts utilisés en intérieur ou en extérieur (module central, module d’intérieur, module d’extérieur, pluviomètre et anémomètre) et fournissant ensuite des données accessibles à travers une API dédiée.

Au sein du catalogue de package mis à disposition sur le site de Constellation et produits par la communauté, on retrouve un package NetAtmo permettant de remonter l’état de toutes les sondes sous forme de StateObjects et il nous suffit alors de créer un package .NET pour gérer cette « intelligence » souhaitée.

Dans ce scénario, notre package a besoin de connaitre l’état de la voiture et du pluviomètre, pour cela, nous pouvons utiliser l’attribut « StateObjectLink » sur les propriétés souhaitées afin de lier notre package d’intelligence aux données des packages NetAtmo et Tesla :

[StateObjectLink(Package = "NetAtmo", Name = "Pluviomètre.Rain")]
public StateObjectNotifier Pluviometre { get; set; }

[StateObjectLink(Package = "Tesla", Name = "Tesla.State")]
public StateObjectNotifier Tesla { get; set; }

Puis au démarrage du package, il suffit de s’attacher au changement d’état du pluviomètre pour être notifier en cas de pluie afin de vérifier si le toit ouvrant est bien fermé sinon, le fermer de manière automatique en invoquant le MessageCallback « CommandRoof » du package Tesla :

this.Pluviometre.ValueChanged += (s, e) => // lorsque l'état du pluviomètre change
{
    if ((int)e.NewState.DynamicValue > 0) // si de la pluie est mesurée
    {
        PackageHost.WriteInfo("Il pleut !");
        if (this.Tesla.DynamicValue.RoofOpeningPercent.AssociateValue != 0) // si le toit ouvrant n'est pas complément fermé
        {
            PackageHost.WriteInfo("Toit ouvrant ouvert ! Fermeture automatique");
            PackageHost.CreateMessageProxy("Tesla").CommandRoof(vehiculeId, 0);
        }
    }
};

Il est également possible de connaitre via le StateObject « Tesla.Drive » si le véhicule est en mouvement et sa position géographique pour vérifier qu’il est bien à proximité de la station météo utilisée ou sinon et au besoin, utiliser un service tiers de météo comme source d’information (ex : le package Forecast.io du catalogue disponible).

Contrairement au Model X, le Model S ne propose pas des portes qui soient pilotables à distance, cependant cet exemple, utilisant le toit ouvrant, illustre de manière simple la mise en œuvre d’un traitement externe ayant une possibilité d’interaction avec le véhicule via la Constellation.

Scénario 2 – Préchauffage/Pré climatisation le matin

En se basant sur les déplacements au sein de la maison ou du bureau, le module d’intelligence ambiante historise les déplacements dans les pièces et donc le parcours réalisé avant de quitter le lieu et anticipe ainsi le départ afin de préparer le véhicule en préchauffant ou pré-climatisant le véhicule en fonction des conditions météos.

Présentation des capteurs Estimote

Les capteurs Estimote utilisés ici sont des stickers résistants à l’eau et permettant simplement de rendre « connecté » n’importe quel objet sur lequel cet élément est collé.

Ces stickers intègrent des capteurs de déplacement, de température et d’orientation et peuvent renvoyer ces informations aux périphériques à proximité en plus de leur état logique (batterie, firmware…).

Ils peuvent communiquer selon deux protocoles de communication : iBeacon ou Nearable qui reposent tout deux sur une utilisation de Bluetooth Low Energy (BLE 4.0) ce qui permet de communiquer avec de multiples périphériques.

Analyse des parcours usuels et scénario retenu

Dans une application mobile déployée sur le téléphone, il est possible de remonter les informations broadcastées de manière régulière au server Constellation. Il est possible, pour cela, d’utiliser le SDK fourni par Estimote ou pour les plus courageux, implémenter les communications Bluetooth de manière à gérer les trames reçues, dans le cas présent une application PhoneGap permet de gérer ce cas avec notamment l’emploi d’un plugin spécifique.

En pratique, le suivi permet de tracer les modifications des observations des stickers et des signaux liés qui pourront être historisées à travers la Constellation en communiquant les StateObjects utiles via l’API REST disponible.

Si l’on traduit cela à des emplacements de stickers spécifiques et en filtrant quelque peu les données observées, on récupère des statistiques qui, une fois retranscrits sur un plan et dans une séquence organisée dans le temps, permettent d’identifier le scénario à retenir dans un créneau horaire visée :

Il est également possible d’analyser dynamiquement les déplacements et en extraire un « pattern » habituel pour une journée type : jour de semaine, weekend, jour férié… pour déclencher des scénarios sur des habitudes de déplacements identifiés dans la maison.

Plusieurs limites apparaissent dans cette première implémentation mais ces dernières ne limitent pas pour autant la possibilité d’appliquer le traitement souhaité. Parmi celles-ci on peut indiquer qu’il n’y a pas de différenciation des utilisateurs activant les capteurs ou que l’on n’a pas d’état direct d’une porte par exemple notamment si elle est déjà ouverte.

Néanmoins, à travers l’implémentation actuelle, les captures permettent de faire fonctionner le scénario et devront faire l’objet d’amélioration dans le traitement des messages émis par l’application ou reçus dans la Constellation.

Vérification des paramètres météorologiques depuis le package Netatmo

A travers le package NetAtmo, on récupère les informations météos de la station et on récupère également la température observée.

Aussi, la climatisation est un instrument à utiliser avec parcimonie et il est recommandé de ne pas excéder 5°C d’écart entre l’habitacle et l’extérieur. C’est la raison pour laquelle la température extérieure est récupérée et utilisée au sein de la règle mise en œuvre que voici :

SI la [Température Extérieure] > 25°C ALORS
  Mettre la température à [Température Extérieure] – 5
SINON
  Mettre la température à 20°C

Dès lors, ce paramètre évidemment modifiable dans la configuration du module garantit un confort optimal d’usage du véhicule.

Commandes et contrôle du véhicule

La récupération de l’état du système de climatisation permet d’éviter de modifier les paramètres qui pourraient avoir déjà été spécifiés par l’utilisateur dans le véhicule ou depuis l’application, ceci afin de ne pas écraser les valeurs spécifiées. Les données remontées nous permettent de récupérer l’état de la climatisation ainsi que les températures à l’intérieur du véhicule.

Pour récupérer l’état de la climatisation de la voiture et du capteur de température extérieure, on créée des propriétés « StateObjectLink »  :

[StateObjectLink(Package = "NetAtmo", Name = "Jardin.Temperature")]
public StateObjectNotifier TemperatureExt { get; set; }

[StateObjectLink(Package = "Tesla", Name = "Tesla.Climate")]
public StateObjectNotifier ClimTesla { get; set; }

Lorsqu’il est l’heure de partir, on vient définir la température de consigne pour le conducteur et le passager grâce au MessageCallback « CommandTemperature » du package Tesla en fonction de la température extérieure mesurée par notre sonde NetAtmo :

if ((int) this.TemperatureExt.DynamicValue > 25)
{
   int targetTemperature = (int) this.TemperatureExt.DynamicValue - 5; 
   PackageHost.WriteInfo("Il fait trop chaud, réglage de la climatisation de la Tesla à {0}°C !" , targetTemperature);
   PackageHost.CreateMessageProxy("Tesla").CommandTemperature(vehiculeId, targetTemperature, targetTemperature);
}
else
{
    PackageHost.WriteInfo("Réglage de la climatisation de la Tesla à 20°C !");
    PackageHost.CreateMessageProxy("Tesla").CommandTemperature(vehiculeId, 20, 20);
}

Scénario 3 – Gestion de la charge liée au planning

Précisions sur la charge et la recharge

Même si la Model S propose une autonomie suffisante pour effectuer plusieurs centaines de kilomètres (420 km réels pour le modèle concerné 85D), il arrive parfois que le véhicule ne soit pas assez chargé pour le parcours du lendemain. Là où avec un modèle thermique, il suffit de se rendre dans une station-service et repartir en quelques minutes, la recharge à domicile prend davantage de temps (Pour information, chez moi de 0 à 90% en environ 13h, en pratique quelques heures suffisent car la charge n’est jamais si peu élevée).

Avec l’ensemble des modèles électriques du marché on a l’obligation d’attendre plus ou moins selon le véhicule, l’équipement à domicile ou les bornes sur lesquelles l’on est connecté. Dans l’optique de parcourir plusieurs centaines de kilomètres sans problèmes, Tesla est arrivé avec une approche disruptive et novatrice et propose un réseau, toujours en expansion, de bornes de recharge ultra-rapides appelées « superchargeurs » qui facilitent le déplacement lors des longs parcours sans effectuer des arrêts prolongés.

Synopsis

Dans le scénario retenu, on souhaite inspecter l’agenda de l’utilisateur et le calendrier professionnel pour vérifier les déplacements prévus, leur emplacement et donc vérifier que la charge du véhicule sera suffisante pour se rendre au rendez-vous ou s’il faut charger le véhicule en le connectant à domicile à la veille ou en partant légèrement plus tôt en passant via un superchargeur.

Vérification du planning de la journée et récupération des détails des événements

La plateforme Office 365 est accessible à travers l’API Microsoft Graph qui permet également de se connecter à de multiples autres plateformes, dans le cas présent nous souhaitons récupérer le calendrier et les événements contenus.

Afin de récupérer les événements à venir du calendrier, il est possible d’utiliser l’API dédiée et exécuter la méthode suivante :

https://graph.microsoft.com/beta/me/events?$top=5

A noter que cette méthode supporte les compléments de requête en supportant le protocole OData ce qui permet de filtrer davantage sur des propriétés des événements. Ces derniers ainsi retournés permettent de récupérer entre autres l’emplacement du rendez-vous, la date et l’heure précise ce qui seront utiles pour les traitements qui suivent.

Encore une fois, il existe un package Constellation permettant d’injecter un événement issu du calendrier dans un StateObject sur la Constellation

Calcul de l’itinéraire et récupération des informations de parcours

Pour réaliser le calcul de l’itinéraire, on retrouve plusieurs plateformes dédiées et qui proposent des fonctionnalités géographiques. Afin d’anticiper sur d’autres scénarios qui seront implémentés par la suite, nous choisissons d’utiliser la plateforme proposée par Here.

Voici la requête (GET) permettant de calculer l’itinéraire avec les alternatives utiles et le profil d’élévation :

https://route.cit.api.here.com/routing/7.2/calculateroute.json
?app_id={APP_ID}&app_code={APP_CODE}
&waypoint0=geo!51.325947,0.704923
&waypoint1=geo!51.093373,1.119516
&mode=fastest;car;traffic:disabled;
&alternatives=3
&routeAttributes=shape
&returnelevation=true

Il est ensuite possible de régénérer un itinéraire incluant l’arrêt au superchargeur en tenant compte de nombreux paramètres (trafic prédictif, heure de départ/arrivée, temps de charge…) ce qui peut être fait en utilisant le package Here disponible dans le catalogue et exposant les méthodes sous forme de MessageCallbacks permettant à tout autre package de tirer profit des fonctionnalités (géocodage, calcul d’itinéraires avancés, génération d’isochrone…).

Récupération de l’état de charge et stratégie de recharge

La récupération du niveau de charge du véhicule s’effectue par la récupération du dernier StateObject concerné dans la Constellation et les données renvoyées permettent de récupérer l’état de la batterie ainsi que des informations sur l’autonomie estimée du véhicule.

Voici par exemple la valeur de mon StateObject « Tesla.Charge » actuel :

{
  "BatteryCurrent": { "AssociateValue": 0, "Unit": "Ampere" },
  "BatteryLevel": { "AssociateValue": 69, "Unit": "Percentage" },
  "ChargeActive": false,
  "ChargePortOpen": false,
  "ChargerActualCurrent": { "AssociateValue": 0, "Unit": "Ampere" },
  "ChargeRate": { "AssociateValue": 0, "Unit": "KilometerPerHour" },
  "ChargerMaxCurrent": { "AssociateValue": 0, "Unit": "Ampere" },
  "ChargerPower": { "AssociateValue": 0, "Unit": "KilowattHour" },
  "ChargerVoltage": { "AssociateValue": 0, "Unit": "Volt" },
  "RangeBatteryEstimated": { "AssociateValue": 192.21, "Unit": "Mile" },
  "RangeBatteryNominal": { "AssociateValue": 180.09, "Unit": "Mile" },
  "RangeBatteryRated": { "AssociateValue": 225.11, "Unit": "Mile" },
  "RangeStart": null,
  "Supercharging": false,
  "TimeToCharge": { "AssociateValue": 0, "Unit": "Minute" }
}

Un phénomène lié au caractéristique physique et chimique des batteries occasionne une légère déperdition d’énergie même au cours d’une période d’inactivité du véhicule, on parle alors de vampirisation de la batterie à l’arrêt, pouvant être négligeable dans la majorité des cas, on peut estimer ce phénomène à 1 km de perte / heure d’inactivité.

La charge s’effectue à une vitesse dépendante de l’équipement de recharge, mesurable via l’API et donc le package. A domicile, je charge à une vitesse de 32 kilomètres par heure de recharge et on peut alors calculer le temps nécessaire pour la recharge et on pourrait même envisager de piloter la recharge automatiquement (début et arrêt de charge).

Pour calculer le temps, l’énergie consommée et le coût estimé :

{Charge nécessaire} = ({distance du parcours} - {distance restant} + [marge confort/arrivée]) 
* {consommation estimée sur le parcours} / [efficacité de recharge] 
{Temps} = {Charge nécessaire} / {Taux de chargement}
{Coût} = {Charge nécessaire} * [taux du kwh]

En pratique, dans un cas appliqué, la charge nécessaire :

{Charge nécessaire} = (150 kilomètres - 60 kilomètres restants + 40 kilomètres de marge) 
* (220 kwh/km moyen sur le parcours) 
/ (0.82 efficacité de recharge moyenne sur équipement 220V/32A)
{Charge nécessaire} = Environ 35 kwh (34.9 kwh)

Le temps nécessaire :

{Temps} = 35 / 7.4 kwh en recharge
{Temps} = 280 min environ soit 4h40

Le coût associé :

{Coût} = 35 kwh * [0.17£]      // 0.22 €, oui l'électricité est chère en UK
{Coût} = 5,95 £         // 7,70 €

A noter, l’API de Tesla et donc notre package Tesla dans la Constellation retourne également le temps estimé de charge nécessaire pour atteindre la limite qui serait éventuellement configurée sur le véhicule. Il est alors aisé de prendre la décision et de ne pas « oublier » de charger en prévision du rendez-vous et donc d’arriver à l’heure pour ce dernier.

Alternative via superchargeurs sur le parcours

Une autre option consiste alors à étudier la possibilité d’utiliser un superchargeur sur la route et calculer le temps nécessaire pour s’y rendre au cours du parcours, charger et continuer le chemin.

Pour cela, nous avons créé une Web API dédiée, consommée depuis le package de gestion de la recharge et permettant de trouver un superchargeur à proximité d’une route possible pour se rendre à l’emplacement prévu, calculée par l’API Here décrite plus tôt, et donc ensuite de calculer les temps nécessaires de parcours et de charge.

Le traitement réalisé peut être illustré comme suit :

Il est alors possible enfin d’ajouter un déplacement dans l’agenda piloté via le package vers le Microsoft Graph pour intégrer cet arrêt de recharge au planning de la journée qui sera présenté en arrivant dans le véhicule.

Comparaison des deux alternatives

Ces alternatives reposent sur des estimations dans la recharge et dans le parcours et de fait, plusieurs limitations apparaissent notamment la prise en compte avancée des éléments du calcul d’itinéraire (pas de profil d’élévation, de conditions météo et trafic) mais également sur les informations du superchargeur (puissance de la borne, disponibilité en temps réel, prise en compte du l’état de la batterie notamment le besoin de préchauffage, fréquentation/utilisation prévue…) ce qui peut limiter quelque peu la justesse de la proposition, ces traitements pourront être améliorées dans la continuité de l’implémentation.

D’une manière simple, l’utilisateur peut alors observer un résumé de l’information sur son application mobile sur son téléphone ou n’importe quel périphérique connecté et peut alors prendre la décision en ayant connaissance du temps nécessaire et du coût pour chacune des options qui s’offrent à lui, apportant un réel gain de temps et un confort au quotidien.

Pour aller plus loin

La plateforme Constellation permet d’apporter le squelette facilitant les échanges entre les plateformes externes, les APIs personnalisées ou les objets connectés et ces usages dépassent dans le cas présent, la domotique habituellement présentée.

Les objets connectés sont en effet de plus en plus présents dans notre quotidien et le véhicule n’est pas en reste avec une nouvelle fois davantage d’échanges d’informations directement rendus possibles et nous avons pu le voir ici, dans la Constellation, l’ensemble des objets connectés peuvent interagir avec le véhicule ou fournir une information utile pour faire un traitement encore plus riche.

La Tesla, en véhicule avant-gardiste, propose des fonctionnalités très originales, souvent utiles au quotidien, parfois plus triviales mais toujours dans le sens de l’innovation et des avancées permettant de faciliter l’intégration de ce véhicule dans un contexte d’intelligence ambiante.

Nicolas Boonaert, MVP – Bing Maps for Enterprise, CEO @ Ketto

The post Connectez votre voiture Tesla dans Constellation appeared first on Constellation.

J’ai la chance de faire partie des beta-testeurs de la plateforme Constellation développé par Sébastien Warin. J’utilise cette plateforme pour orchestrer des services que je fais tourner sur des serveurs répartis à travers la France et dans Microsoft Azure.

La Constellation fonctionne à la fois sous Windows et Linux me permettant de connecter des RaspberryPi v1 tournant sur lesquels j’ai installé Mono. Un de ces boards me permet de gérer une serre qui se trouve dans le jardin. J’ai aussi des Netduino tournant sous .NET Microframework (implémentation open source d’un sous ensemble de .NET et tournant directement sur des processeurs sans OS). Sur un de ces Netduino, j’ai une carte de prototypage GSM Quectel M95 que j’utilise comme passerelle SMS avec un abonnement free à 2€.

La grande difficulté est la gestion de la réception et l’émission de SMS, tout se faisant en port série avec des commandes AT. Beaucoup de « plaisir » à faire fonctionner tout cela. Pour avoir un minimum de sécurité, je gère directement dans le board les numéros de téléphones autorisés ainsi que leur niveau d’accréditation. Après ce premier niveau de sécurité, pour des commandes avancées, un code de sécurité aléatoire est renvoyé, le message doit ensuite être renvoyé. Il est en effet possible de spoofer un SMS facilement, mais la réponse à l’expéditeur arrive toujours au numéro d’envoi. Cela me permet de gérer un très bon niveau de sécurité.

Comme il existe différente API pour se connecter à la Constellation, en .NET, Python, Javascript ou bien .NET Microframework, je peux facilement connecter mon board dans ma Constellation.

La Constellation me permet, au démarrage du board ou à chaque fois que je fais une mise à jour des paramètres sur le serveur de recevoir automatiquement les nouveaux settings. Au niveau du code, rien de plus simple :

ConstellationProxy constellation = new ConstellationProxy("http://ipserver:port", "clédesurité", "NOMDUBOARD", "Notif");
constellation.SettingsReceived += constellation_SettingsReceived;
constellation.RequestSettings();

static void constellation_SettingsReceived(System.Collections.Hashtable settings)
{   // Numéros de téléphones
    if (settings.Contains("PhoneNumbers"))
    {
        AuthorisedNumbers = settings["PhoneNumbers"].ToString().Split(';');
    } 
    //Privilèges d'access 
    if (settings.Contains("Access"))
    {
        Access = settings["Access"].ToString().Split(';');
    }
}

Constellation fourni une dll délivrée par Nuget permettant d’y avoir accès, une fois connecté et initialisé, il est possible de récupérer les paramètres dont j’ai besoin, dans mon cas, les numéros de téléphones et les privilèges d’accès.

A chaque SMS reçu et validé, j’envoie un message au groupe « SMS » qui a 3 propriétés, From (le numéro de téléphone de l’expéditeur), le Message (le corps du SMS) et le moment où le SMS a été reçu

constellation.SendMessage(new Scope(ScopeType.Group, "SMS"), "ReceiveSMS", new SMSNotif.SMS { From = mySMS.From, Message = mySMS.Message, Date = mySMS.Date });

J’ai d’autres packages tournant sur l’autres machines qui peuvent s’abonner à ce groupe et donc recevoir un événement lors de la réception d’un SMS. Leur consommation est également triviale :

[MessageCallback]
public void ReceiveSMS(dynamic mySMS)
{ 
  // Récupération des propriétés de l'objet
  string From = (string)mySMS.From;
  string Message = (string)mySMS.Message;
}

Quel rapport avec mon Nabaztag ?

C’est là que les choses deviennent intéressantes. Beaucoup se souviennent certainement des Nabaztag, ces lapins super sympas et connectés. Précurseurs des objets connectés, la société qui les a créée n’a malheureusement pas survécu. Mais le code des lapins a été publiés et on a vu des quelques serveurs s’ouvrir pour leur apporter une nouvelle vie.

J’utilise openJabNab.fr qui est géré par un groupe de passionnés et offrent un service de qualité proposant des API. Et c’est notamment cet aspect qui m’intéressait particulièrement. En effet, je compte utiliser la seconde vie de mon Nabaztag pour les notifications de ma Constellation.

Pour ce faire, il est nécessaire de paramétrer son Lapin en créant un compte, la manipulation est vraiment simple et rapide. Il faut ensuite activer des plugins. Celui que je vais utiliser est très simple, c’est le “Plugin TTS, envoi de texte au lapin”, son nom court est “tts”. Nous en aurons besoin. En regardant rapidement la documentation, la fonction est “say” et prends le paramètre “text” en entrée.

Le fonctionnement de l’ensemble des API est similaire, il faut d’abord récupérer un token puis l’utiliser dans l’appel de l’API. L’appel à l’URL suivante en remplaçant mylogin et mypassword par le login et mot de passe, retourne ensuite un XML.

http://openjabnab.fr/ojn_api/accounts/auth?login=mylogin&pass=myPassword

En cas d’erreur:

<?xml version="1.0" encoding="UTF-8"?>
<api>
<error>Access denied</error>
</api>

En cas de succès:

<?xml version="1.0" encoding="UTF-8"?>
<api>
<value>77a18144bb6adefbe29afdb16fb5e3ed</value>
</api>

Le token est la valeur value. L’appel de l’API text to speech se fait ensuite de la façon suivante:

http://openjabnab.fr/ojn_api/bunny/0123456789ab/tts/say?text=je+suis+une+lapine+qui+aime+les+lapins&token=77a18144bb6adefbe29afdb16fb5e3ed

L’adresse MAC du lapin doit être positionnée à la place de la chaîne 0123456789ab. Le texte qui sera lu sur le Nabaztag sera donc “je suis une lapine qui aime les lapins”. Vous recevez également une confirmation de ce type:

<?xml version="1.0" encoding="UTF-8"?>
<api>
<ok>Envoi de 'je suis une lapine qui aime les lapins' au lapin '0123456789ab'</ok>
</api>

Pour créer un Package, il suffit de créer un projet Constellation après l’installation du SDK Constellation pour Visual Studio.

Nous allons ensuite ajouter 4 settings, pour le login et mots de passe ainsi que pour les lapins. Je possède plusieurs Lapin et plutôt que de les appeler par leur adresse MAC, j’utilise un nom, je vais donc utiliser de façon vraiment simple un string contenant les noms séparés par des point-virgules et faire la même chose pour les adresses MAC. Côté des variables, lors de la lecture des settings, je stocke les informations dans des string et tableau de string:

private string myLogin;
private string myPassword;
private string[] MACaddresses;
private string[] FriendlyNames;

private void UpdateSettings()
{
    myLogin = PackageHost.GetSettingValue<string>("Login");
    myPassword = PackageHost.GetSettingValue<string>("Password");
    MACaddresses = PackageHost.GetSettingValue<string>("MACs").Split(';');
    FriendlyNames = PackageHost.GetSettingValue<string>("Friendlys").Split(';');
    PackageHost.WriteInfo("Package NabaztagNotif updated");
}

Ensuite, je crée ma fonction de call back que j’appellerais depuis un autre package quand je voudrais envoyer un texte à mon lapin:

[MessageCallback]
public void Say(string MACaddress, string texttosend) { 
    Try {
        WebClient instanceHTTP = new WebClient();
        string strReq = "http://openjabnab.fr/ojn_api/accounts/auth?login=" + myLogin + "&pass=" + myPassword;
        Uri MyURI = new Uri(strReq);
        string retval = instanceHTTP.DownloadString(MyURI); 
        // Recherche du mot "value" contenu dans le XML renvoyé
        if (retval.Contains("value")) {
            int start = retval.IndexOf("<value>");
            int end = retval.IndexOf("</value>");
            string token = retval.Substring(start + 7, end - start - 7);
            strReq = "http://openjabnab.fr/ojn_api/bunny/" + MACaddress + "/tts/say?text=" + WebUtility.HtmlEncode(texttosend) + "&token=" + token;
            MyURI = new Uri(strReq);
            retval = instanceHTTP.DownloadString(MyURI);
            if (retval.Contains("<ok>"))
                PackageHost.WriteInfo("Success sending message to Nabaztag {0}", nabaztagname);
            else
                PackageHost.WriteError("Error sending message to Nabaztag {0}", nabaztagname);  }
        else {
            PackageHost.WriteError("Error sending message to Nabaztag {0}, error: authentication", nabaztagname);  } }
    catch (Exception ex) {
        PackageHost.WriteError("Error sending message to Nabaztag {0}, error: {1}", nabaztagname, ex.ToString());  }  }

Il considère que le login et le mot de passe ont déjà été encodé pour l’URL. Il est nécessaire d’utiliser la fonction WebUtility.HtmlEncode s’ils ne le sont pas dans vos settings.

L’appel se fait de façon tout à fait classique comme cela (en considérant que le nom du package est “NabaztagNotif”):

PackageHost.CreateScope("NabaztagNotif").Proxy.Say("monlapin", “je suis un lapin qui aime les lapines”);

Comme notre package est connecté à la Constellation, une simple page Javascript ou un script Python ou Powershell peuvent également envoyer des messages à notre Nabaztag.

Pour ma part, depuis mon board et l’API Constellation pour NETMF, à la réception de SMS, j’envoie un message au package NabaztagNotif me permettant de lire les SMS reçus.

Voilà un exemple d’utilisation de Constellation mais aussi d’API permettant de faire revivre vaux lapins.

Bon lapinage

Laurent Ellerbach, Evangelist Lead, Central and Eastern Europe, Microsoft

The post Faire parler son Nabaztag en envoyant des SMS grâce à la Constellation appeared first on Constellation.

Lorsque nous avons acheté notre maison, nous avons entamé de lourds travaux de rénovation ce qui m’a permis de passer du câble multifonction blindé à chaque point de contrôle (interrupteurs) dans l’optique de pouvoir facilement ajouter des fonctionnalités domotique sans avoir recours à des solutions sans fil comme le Z-Wave assez coûteux.

Après l’installation de pas moins d’une dizaine volets électrique dans la maison, il me fallait une solution de pilotage à la fois simple, fiable et surtout économique. De plus cette solution devra être ouverte me permettant de concevoir ma propre interface de contrôle sur tout type de support et de pouvoir facilement ajouter de l’intelligence.

Grace à la plateforme Constellation, un Raspberry Pi et quelques Arduinos, j’ai pu concevoir mon propre système de gestion des volets.

La conception

Concrètement chaque volet dispose de deux phases : une pour la montée et une autre pour la descente.

L’idée est donc de piloter ces deux phases avec des relais. Pour garder le contrôle manuel des volets (c’est-à-dire à partir des interrupteurs encastrés dans le mur), j’ai connecté chaque interrupteur bistable au système pour déclencher les volets (obligatoire pour une certification WAF J).

Pour cela derrière chaque interrupteur des volets, j’ai placé une carte de contrôle avec deux relais 220V et deux entrées. Chaque carte de contrôle est connectée sur un câble multifonction qui arrive à chaque volet. On utilise donc 6 fils : deux pour les entrées des interrupteurs (montée et descente), deux pour la commande des deux relais (montée et descente) et deux pour l’alimentation (5V ou 12V en fonction de vos relais).

Côté budget, comptez moins de 3€ par volet.

L’ensemble des câbles se rejoignent tous jusque dans ma baie réseau au RDC. Chaque volet a donc besoin de deux sorties pour les relais et deux entrées pour l’interrupteur bistable. Avec 10 volets, ça nous donne donc 20 sorties et 20 entrées, beaucoup trop pour un Raspberry !

Toujours dans l’optique de baisser les coûts, j’utilise un réseau d’Arduino Mini Pro acheté moins de 2€ pièce.

Chaque Arduino peut gérer jusqu’à 3 volets. Ils sont tous installés sur une carte et connectés en série sur un bus I2C sur lequel est également connecté un Raspberry qui sera le cerveau des volets, lui-même connecté dans la Constellation.

N’importe quel objet, page Web ou programme connecté dans la Constellation pourra envoyer un ordre à chaque volet. Chaque ordre sera traité par le package Constellation qui tourne sur le Raspberry qui, commandera l’Arduino associé via le bus I2C qui lui-même activera le relais correspondant à l’ordre de montée ou descente du volet cible !

Conception logicielle

Une fois nos volets connectés sur les cartes relais reliés aux Arduinos, il suffit d’activer les sorties pour basculer l’état des relais et donc piloter la montée ou la descente de chacun de nos volets.

Par exemple pour une montée :

digitalWrite(volets[i].relaisMontee, HIGH);
digitalWrite(volets[i].relaisDescente, LOW);

Pour capter un changement d’état sur les interrupteurs bistables, il suffit de lire l’entrée correspondante configurée en pull-up. Si l’entrée change d’état à l’état LOW c’est qu’on vient d’appuyer sur le bouton de montée :

if (digitalRead(volets[i].buttonMontee) == LOW && volets[i].previousSens != 1)
{
  // Demande de montée
}

Pour la communication des Arduino avec la base Raspberry, j’utilise le protocole I2C. Chaque Arduino à son adresse 0x11 pour le 1^er, 0x12 pour le 2^ème, etc.. en esclave sur le bus. Le Raspberry est maître.

Lors du setup, j’attribue l’adresse de mon Arduino et configure des callbacks pour la réception et l’émission :

Wire.begin(SLAVE_ADDRESS);
Wire.onReceive(receiveData);
Wire.onRequest(sendData);

Pour la lecture, dès qu’il y a quelque chose sur le bus, je récupère un Int dont les deux 1^ers bits m’indiquent le n° du volet, suivi d’un bit pour savoir si je dois allumer ou eteindre le volet. En cas d’allumage, le dernier bit permet de connaitre le sens (montée ou descente) :

while(Wire.available()) 
{
    int dataReceived = 0;
    dataReceived = Wire.read();
    rawVal += dataReceived;
}
int rawInt = rawVal.toInt();
int numVolet = bitRead(rawInt,2) & bitRead(rawInt,3)*2;
int allumageVolet = bitRead(rawInt,1);
int sensVolet = bitRead(rawInt,0);
// Envoyer l'ordre sur les sorties du volet correspondant

Pour connaitre l’état des interrupteurs depuis le Raspberry, chaque Arduino écrit sur le bus un Int avec le même format pour indiquer pour chaque volet son état :

Wire.write(/* int représentant l’état du volet */);

Maintenant que je peux piloter l’ensemble de mes volets depuis mon Raspberry, j’utilise la plateforme Constellation pour tout connecter facilement.

Grace au SDK Constellation dans Visual Studio et aux Python Tools for Visual Studio, j’ai créé un package Constellation en Python.

Le package expose des méthodes dans la Constellation pour le contrôle et publie des « StateObjects » sur l’état de chaque volet.

def ActionVoletMessageCallback(data):
    # Action à envoyer à un volet.
    try:
        volet = GetShutter(data["shutterName"].lower())
        actionStr = data["actionShutter"].lower()
     if actionStr == "montee":
            volet.Open()
        elif actionStr == "descente":
            volet.Close()
        else:
            volet.Stop()
    Constellation.WriteInfo("ActionVolet: %s => %s ", (volet.nom, actionStr))

Les methodes Open/Close/Stop écrivent sur le bus I2C avec la commande I2CSet à destination de l’adresse de l’arduino cible, l’entier représentant l’ordre à exécuter :

commande = 'i2cset -y 1 %s 0x%x' % (self.adresse, i)
os.system(commande)

Pour la lecture sur le bus, j’utilise la commande « i2cget ».

f = os.popen('i2cget -y 1 %s' % self.adresse, 'r')
retour = f.read()

Une fois l’entier représentant l’état de chaque volet décrypté, je publie dans la Constellation un StateObject avec toutes les infos :

# Changement, on met à jour le stateobject
 Constellation.PushStateObject(volet.nom, volet.etat, "Shutter",
   {
       "Adresse": volet.adresse,
       "Numero": volet.numero,
       "Statut inversé" : volet.inverseStatut,
       "Commande inversée" : volet.inverseCommande
   })

Une fois mon package développé, je peux directement depuis Visual Studio le publier sur mon serveur et le déployer sur une sentinelle de ma Constellation.

Au préalable j’ai installé une Sentinelle Constellation sur mon Raspberry. Il me suffit ensuite de lancer mon package depuis l’interface Web de contrôle de ma Constellation.

Cette interface me permet également de suivre en temps réel les logs de mes packages :

Aller plus loin avec Constellation

A ce stade l’état de chaque volet de ma maison est publié dans la Constellation et je suis capable de piloter chacun d’entre eux en envoyer un message dans la Constellation à destination de mon package Python.

La suite logique est de créer une interface de pilotage. Pour cela je vais utiliser l’API Constellation pour AngularJS me permettant de créer une application HTML/JS connectée dans la Constellation avec le framework Angular de Google.

Grace à la Constellation, le code Javascript se résume à cela :

app.controller('ShutterAngularController', ['$scope', 'constellation', function ($scope, constellation) {

    constellation.intializeClient("http://constellation.myhome.lan:8088/", "MonAcessKey", "HomeControl");

    var MesVolets = {};
    constellation.onUpdateStateObject(function (message) {
        $scope.$apply(function () {
            $scope.MesVolets[message.Name] = message;
        });
    });

    constellation.onConnectionStateChanged(function (change) {
        if (change.newState === $.signalR.connectionState.connected) {
            constellation.requestSubscribeStateObjects("*", "ShutterController", "*", "*");
        }
    });

    $scope.actionShutter = function (shutter, action) {
        constellation.sendMessage({ Scope: 'Package', Args: ['ShutterController'] }, 'ActionVoletMessageCallback', { 'shutterName': shutter.Name, 'actionShutter': action });
    };

    constellation.connect();
}]);

Dans mon contrôleur, je me connecte à ma Constellation et je m’abonne au StateObject du package « ShutterController ». A chaque réception d’un state object, je l’ajoute dans mon scope Angular. De plus j’ai ajouté une méthode pour envoyer un message de contrôle à mon package Python.

Il ne reste plus qu’à faire une vue HTML en faisant une boucle sur notre variable de scope « MesVolets » :

<div class="list-group-item" ng-repeat="shutter in ShutterController">
    <h3>                        
        {{shutter.Name}}
        <em class="pull-right btn-group" role="group" aria-label="...">
            <button type="button" 
                class="btn btn-default glyphicon glyphicon-chevron-up" 
                ng-class="{ active: shutter.Value==='Montee' }" 
                ng-click='actionShutter(shutter, "montee")'>
                </button>
            <button type="button" 
                class="btn btn-default glyphicon glyphicon-stop" 
                ng-class="{ active: shutter.Value==='Arret' }" 
                ng-click='actionShutter(shutter, "stop")'>
                </button>
            <button type="button" 
                class="btn btn-default glyphicon glyphicon-chevron-down" 
                ng-class="{ active: shutter.Value==='Descente' }" 
                ng-click='actionShutter(shutter, "descente")'>
                </button>
        </em>
    </h3>
</div>

Et voilà comment créer une première interface Web de supervision et de contrôle de l’ensemble des volets à la maison.

Les propriétés des volets étant exposées dans la Constellation, il devient facile d’ajouter de l’intelligence dans la maison. Par exemple, j’ai également un autre Raspberry avec un capteur de luminosité TSL2561 dans ma Constellation ce qui me permet d’ouvrir et fermer les volets en fonction du seuil de luminosité ou encore de fermer automatiquement les volets lorsque je lance un film sur mon XBMC (XBMC/Kodi étant lui-même connecté dans ma Constellation).

Grace à la plateforme Constellation, l’interconnexion des objets devient un jeu d’enfant comme l’orchestration et le déploiement de mes programmes à travers les différents devices de la maison.

Ainsi, moyennant un budget inférieur à 100€, j’ai pu connecter et rendre intelligents mes dix volets.

Lucas Dupuis

The post Connecter ses volets dans la Constellation avec des Arduino et un Raspberry appeared first on Constellation.