La prise connectée est un élément phare de la domotique de la maison. Il permet d’allumer ou d’éteindre un équipement branché dessus ou encore de connaitre sa consommation en énergie. Dans mon cas, j’avais besoin d’allumer ou d’éteindre les enceintes de mon média center automatiquement lorsque ce dernier était démarré.

Découvrons ensemble comment créer sa prise connectée avec un ESP8266.

Prérequis

Pour ce tutoriel, il vous faut :

• Un bloc prise avec un interrupteur
• Un transformateur AC/DC 5v
• Un ESP-01 (ESP8266)
• Un régulateur de tension 3.3v
• Un relais 220V pilotable en 5v
• Un transistor, des résistances, des leds, une diode, des condensateurs
• Du fil électrique
• Un pistolet à colle et une drémel
• Un serveur Constellation

Etape 1 : Construire la prise

Dans un premier temps, il nous faut un boitier abordable que nous pourrons ouvrir pour insérer notre ESP à l’intérieur. Après quelques recherches, j’ai opté pour le boitier Renkforce disponible chez Conrad pour 3€ environ.

On commence donc par l’ouvrir pour la vider littéralement :

Puis tous les supports plastique à l’intérieur doivent être cassés pour libérer un maximum de place. Je les ai cassés avec une pince coupante et j’ai fini de retirer le maximum de plastique avec un dremel. Sur cette photo j’avais retiré une partie du fond de la prise pour un autre projet.

Il faut ensuite préparer un câblage avec le relais pour qu’il s’intercale entre l’arrivée de la phase (mur) et la phase distribuée à l’élément branché sur la prise. Mais il faut également garder en tête que l’alimentation de l’ESP doit être permanente :

Mon principal problème dans ce tutoriel a été de tout faire rentrer dans la prise. En effet, l’alimentation + le relais prennent beaucoup de place et tout est rentré au chausse-pied, avec le câblage noyé dans la colle chaude afin d’assurer l’isolation.

Le transformateur alimente donc en 5v un régulateur de tension LM1117 3.3V avec deux condensateurs pour lisser du 3.3v pour l’ESP01.

Il alimente également directement la bobine du relais dont le circuit est interrompu par un transistor NPN BC547 dont la base sera pilotée en saturation par un GPIO de l’ESP.

L’ESP pilote deux leds de statut : une rouge et une verte et possède également son dernier GPIO en input pour un bouton physique placé sur le dessus du boitier. Si vous avez suivi jusque-là et que vous connaissez l’ESP01, vous aurez compris qu’il est impossible de le programmer directement dans la prise, deux des 4 GPIO devant normalement être utilisés pour la communication série.

Pour combler le « trou » du bouton physique original, j’ai choisi de coller par l’intérieur du boitier un petit bout de plexiglas translucide. Je l’ai ensuite percé pour faire passer les deux leds rouge et verte.

Et voilà, on obtient une prise connectée par Wifi avec un ESP8266 avec un bouton poussoir et deux LEDs, reste plus qu’à le programmer !

Etape 2 : la programmation

La fonction de base de la prise est assez simple : couper le courant ou le laisser passer. Dans un premier temps, j’ai uploadé un sketch de base Constellation avec Arduino sur l’ESP01 à l’extérieur de la prise. Je l’ai ensuite branché dans la prise que j’ai enfiché dans le mur. Bazinga, le régulateur 3.3v fait son job, l’ESP boote, se connecte à mon réseau wifi et envoie un « hello world » dans la console Constellation. Pour découvrir comment connecter un ESP8266 à Constellation, suivez ce guide.

Ensuite, j’ai utilisé la librairie Constellation pour ajouter un MessageCallback pour activer ou désactiver le GPIO de la prise, couplé à un StateObject pour maintenir l’état de la prise dans Constellation :

constellation.registerMessageCallback("Switch", MessageCallbackDescriptor().setDescription("Switch le statut du relais."),
  [](JsonObject & json) {
    statutRelais = !statutRelais;
    digitalWrite(gpioRelais, statutRelais);
    constellation.pushStateObject("Status", stringFormat("{ 'IsActivated':%s }", statutRelais ? "true" : "false" ));
  });

Ainsi Constellation a toujours connaissance de l’état de la prise via le StateObject nommé “Status” :

Et tout le monde peut maintenant découvrir et utiliser le MessageCallback “Switch” exposé par notre ESP pour permuter l’état de notre prise :

Bingo, on a donc une prise 220V connectée à Constellation qu’on pourra piloter depuis une page Web, un programme Python ou autre.

Pour vous donnez quelques idées, n’hésitez pas à relire ce tutoriel : Créer un relais connecté.

Etape 3 : Lier sa prise connectée à l’état de son média-center

Dans ma Constellation, je dispose d’un package « brain » développé en C# avec Visual Studio qui contient l’ensemble des règles de la maison (gestion du chauffages, lumières, volets, etc..).

Je l’ai enrichi pour faire en sorte que si Kodi est en train de lire un média (audio ou vidéo) et que la prise n’est pas allumée, alors il invoque le MessageCallback pour allumer la prise. Et inversement pour l’éteindre !

J’ai donc dans une classe C#, ajouté deux StateObjectLinks, c’est à dire que j’ai deux propriétés de mon code C# qui sont liées à mes StateObjets représentant l’état de mon media-center de l’état de ma prise !

Il me reste plus qu’à ajouter un handler sur le changement d’état du State Object de Kodi, afin d’ajouter deux conditions “if” :

• Si la prise est éteinte alors que Kodi joue quelque chose (PlayerState différent de null) alors on allume la prise
• Si la prise est allumée alors que Kodi joue rien (PlayerState null) alors on éteint la prise

Pour allumer ou éteindre la prise, il suffit d’invoquer le MessageCallback “Switch” exposé par notre code Arduino en créant un proxy vers notre package.

public class KodiDemo
{
    /// <summary>
    /// StateObject XBMC. Permet de connaitre les infos de lecture.
    /// </summary>
    [StateObjectLink(Package = "Xbmc", Name = "Kodi Salon NUC")]
    public StateObjectNotifier KodiNotifier { get; set; }

    /// <summary>
    /// StateObject de l'ESP controlant le relais d'activation. Permet de synchroniser les infos de lecture avec la valeur du relais.
    /// </summary>
    [StateObjectLink(Sentinel = "ESP8266-01-001", Package = "ESP_Relay_Button", Name = "Status")]
    public StateObjectNotifier PriseKodi { get; set; }

    public void Start()
    {
        this.KodiNotifier.ValueChanged += (s, e) =>
        {
            if (this.PriseKodi.DynamicValue.Status == false
                && e.IsNew == false
                && e.OldState.DynamicValue.PlayerState == null
                && e.NewState.DynamicValue.PlayerState != null)
            {
                // démarrage.
                PackageHost.WriteInfo("Activation de la prise.");
                PackageHost.CreateMessageProxy("ESP8266_01_002/ESP_Relay_Button").Switch();
            }

            if (this.PriseKodi.DynamicValue.Status == true
                && e.IsNew == false
                && e.OldState.DynamicValue.PlayerState != null
                && e.NewState.DynamicValue.PlayerState == null)
            {
                PackageHost.WriteInfo($"Arret de la prise.");
                PackageHost.CreateMessageProxy("ESP8266_01_002/ESP_Relay_Button").Switch();
            }
        };
    }
}

Et voilà comment en quelques lignes de C# et grâce à Constellation, mes enceintes seront automatiquement allumées ou éteintes selon que mon media-center diffuse ou non un média vidéo ou audio !

Pour aller plus loin

Pour aller plus loin, j’ai ajouté quelques fonctionnalités intéressantes :

• J’ai pluggé le bouton poussoir ajouté sur le dessus de la prise pour qu’il change l’état du relais et mette à jour le state objet en conséquence.
• J’ai ajouté la possibilité d’associer les leds de façade au fonctionnement de la prise en m’inspirant de ce qui existe sur les prises connectées du marché. La led rouge indique le statut de fonctionnement (power on / connexion au wifi en clignotant), la led verte indique l’état du relais.
• J’ai ajouté également un mode « blind », je trouve que c’est une fonctionnalité intéressante mais qui est absente des prises sur le marché : Quand il fait noir dans une pièce et que la prise se reconnecte au wifi, cela peut être gênant de la voir clignoter. Un package de « brain » peut alors gérer les leds directement en fonction de mes volets
• Ensuite, en cas de déconnection du wifi ou de coupure de courant, j’ai prévu un bout de code permettant, au démarrage de l’ESP, de requêter son propre StateObject. Cela permet à la prise de revenir à l’état dans lequel elle était avant la coupure.
• J’ai également fait intervenir l’activation de mon projecteur. Ce dernier push un StateObject. Si le média center est éteint, il envoie un paquet WOL via le package networktools pour l’allumer et envoie une notification de fermeture des volets du salon. Le démarrage de la lecture du média sur kodi pilote la prise d’allumage des enceintes sans action manuelle. Ainsi, le démarrage du projecteur et la lecture sur kodi lancent l’ambiance parfaite pour profiter de mes séries en un seul geste.

The post Créer une prise connectée avec un ESP8266 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.

Cette documentation a été réalisé avec la version 1.0 du package Jeedom ainsi que la version 1.0 du plugin Constellation pour Jeedom.

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

Installation du package Jeedom

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

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 spécifier l’adresse URL ainsi que la clé API de votre installation Jeedom sans le « http:// » :

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

<package name="Jeedom">
  <settings>
    <setting key="ServerUrl" value="192.168.1.20" />
    <setting key="ApiKey" value="123456abcdef" />
  </settings>
</package>

Détails du package

Les Settings

Les StateObjects

Ce package ne comporte aucuns StateObjects.

Les MessageCallbacks

Le package expose 2 types de MessageCallbacks :

• SceneControl :

Ces Message Callbacks ne produisent aucunes réponses (saga).

• SendCommand :

Ces Message Callbacks ne produisent aucunes réponses (saga).

Le plugin pour Jeedom (version 1.0)

Installation

Afin d’éviter de questionner Jeedom toutes les x secondes et pour obtenir les informations le plus rapidement possible, un plugin pour Jeedom a été développé.

Celui-ci vous permet d’envoyer toutes les informations d’un équipement quand une ou plusieurs informations de cet équipement se mettent à jour.

Le plugin peut être téléchargé à cette adresse : http://erwann.laville.free.fr/Jeedom/constellation.zip

Il vous suffit alors de l’extraire dans le dossier plugin de Jeedom. Une fois installé, vous pourrez l’activer dans la liste des plugins sur Jeedom :

Une fois activé, vous aurez accès à la configuration générale du plugin. Il vous faudra indiquer l’url de Constellation (sans le http), le nom de la sentinelle et la clé créditential associée au plugin.

Par la suite vous pouvez ajouter autant d’équipement que souhaités. Chaque équipement créé correspondra à un package différent sur Constellation. Le nom de cet équipement correspondra au nom du package.

Les StateObjects

Le plugin Constellation pour Jeedom envoi un SO par équipement ajouté dans le « package ».

Si vous ajoutez plusieurs commandes d’un même équipement dans le package, les informations de l’équipement seront envoyés au même package dans Constellation à chaque mise à jour de chaque commandes indiquées.

Par exemple dans mon équipement Zwave, je rajoute #[Salle de Bains][Wall Plug][Etat]# et #[Salle de Bains][Wall Plug][Puissance]#. Les informations de mon Wall Plug seront envoyés à Constellation si l’état ou si la puissance changent.

Pour le moment, les SO ont comme nom le chemin de l’équipement dans Jeedom, par exemple : [Salle de Bains][Wall Plug]

N’oubliez pas de rajouter dans Constellation la sentinel et le package, par exemple ici :

<sentinel name="Squeezebox" credential="Standard">
  <packages>
    <package name="Zwave" />
  </packages>
</sentinel>

Les Plugins compatiblent

Du fait du système utilisé (fonction listener) tous les plugins de Jeedom ne sont pas compatibles. Voici une liste non exhaustive des plugins Jeedom essayés :

The post Jeedom dans Constellation appeared first on Constellation.

Ayant fait récemment l’acquisition d’un vidéo-projecteur pour mes soirées films, je me suis vite rendu compte qu’avec les jours qui rallongent, j’ai besoin de fermer les volets de mon salon afin de rester dans une certaine pénombre.

La présentation de mon système de pilotage de volets n’est plus à faire, vous la retrouverez ici. Vous pouvez aussi utiliser des modules Z-Wave comme le FGR-211 qu’on connectera à Constellation via le package Vera ou Jeedom. Dans tous les cas, nous disposons un MessageCallback pour ouvrir ou fermer nos volets !

La problématique qui se pose est la suivante : comment savoir que le projecteur est allumé et que je m’apprête à regarder un film ?

J’ai réfléchi à plusieurs solutions :

• Monitorer la consommation de la prise électrique afin de déduire que le projecteur est allumé
  • Avantages :
    • Permet d’exposer un booléen indiquant que le projecteur est allumé et d’ouvrir/fermer les volets en conséquence
    • Permet de monitorer la consommation en temps réel
    • Permet de monitorer la durée d’utilisation de la lampe du vidéo-projecteur
  • Inconvénients :
    • Nécessite une prise connectée avec conso-mètre (à fabriquer ou à acheter)
    • C’est potentiellement complexe et coûteux
• Surveiller le StateObject de mon médiacenter Kodi (exposé par le package xbmc)
  • Avantages :
    • J’ai déjà une routine surveillant le stateobject pour allumer et éteindre le système de son lorsqu’un média est joué
    • Il n’y a que du code à mettre en place dans le package « cerveau » de la maison
  • Inconvénients :
    • Il n’y a pas de lien direct entre l’allumage du projecteur et une action sur les volets
    • La sélection du film ou du média sur l’écran se fait volets ouverts, et donc c’est potentiellement gênant en cas de luminosité importante
    • Cela ne tient pas compte des autres sources branchées sur le projecteur (TV, console, …)
• Utiliser un déclencheur sur le projecteur
  • Avantages :
    • Montage simple
    • Peu d’investissement
    • Système embarqué trivial
  • Inconvénients :
    • Pas de monitoring de consommation

J’ai retenu la seconde et la troisième option : la seconde option, consistant à surveiller le stateobject de kodi permet l’allumage du système de son lorsqu’un média est lu, que ce soit un film ou un morceau de musique et la troisième option pour déclencher la fermeture des volets à l’allumage du vidéo projecteur.

Prerequis

• Un serveur Constellation
• Un vidéo-projecteur avec une sortie 12V
• Un ESP8266 (ou Arduino connecté) avec un régulateur de tension
• Le SDK Visual Studio

Etape 1 : connecter le vidéo projecteur dans Constellation

En regardant les caractéristiques de mon projecteur, je me suis rendu compte qu’il existait une sortie 12V permettant de déclencher un moteur pour une toile de projection.

À la maison je projette sur un mur blanc, je n’ai donc pas besoin de cette sortie. Il s’agit d’un connecteur jack mono que vous trouverez rapidement chez vous dans votre boite de récup’ ou bien directement sur le net pour quelques centimes.

Il suffit donc d’un ESP8266 (par exemple un ESP-01, très petit et peu cher) et d’un régulateur de tension 3.3v (ex. LD1117v33) acceptant en entrée une tension entre 5 et 15V et le tour est joué !

En effet, le projecteur envoie du 12v sur la sortie dès qu’il est sous tension et du 0v lorsqu’il est éteint. Ainsi notre ESP-01 sera alimenté par cette sortie. Lorsqu’on allume le vidéo-projecteur, l’ESP-01 sera démarré et lorsqu’on éteint le vidéo projecteur, il sera éteint car plus d’alimentation !

Aussi simple que cela !

L’ESP, de son côté, publie simplement toutes les secondes un StateObject ayant une durée de vie de 5 secondes pour indiquer que le projecteur est allumé.

Pour connecter un ESP8266 (ou un Arduino) suivez ce guide ! Une fois connecté dans ma Constellation, je publie le StateObject dans la boucle principale loop()

void loop() {
  constellation.loop();
 
  if(((millis() - lastTime) > 1000) 
    || (millis() < lastTime))
  {
    constellation.pushStateObject("Uptime",  millis(), 5);
    lastTime = millis();
  } 
}

On a donc dans les StateObjects de notre Constellation, un StateObject « Uptime » publié dans mon cas par le package (virtuel)  « ESP01_Projector » qui contient l’uptime de mon projecteur :

Ce StateObject est mis à jour par l’ESP toutes les secondes avec une durée de vie de 5 secondes ! Ainsi je n’ai pas besoin de connaitre la valeur du StateObject, il me suffit juste de vérifier que le StateObject est « Valide » et non « Expiré » !

Si il est valide c’est que dans les 5 dernières secondes il y a bien publié son Uptime, donc l’ ESP est démarré ce qui implique que mon vidéo projecteur est bien démarré (pour alimenter l’ESP) !

En revanche si ce StateObject est expiré, c’est à dire que le StateObject n’a pas été mis à jour durant les 5 dernières secondes or l’ESP est censé le faire à chaque seconde ! L’ESP-01 est donc déconnecté ce qui impliquerai que le vidéo projecteur est arrêté !

Etape 2 : synchroniser le vidéo projecteur avec mes volets

Maintenant, dans mon package « cerveau » de Constellation, il suffit de surveiller ce StateObject et son état expiré ou non pour savoir quelle commande envoyer aux volets.

J’ai donc créé un package « cerveau » en C#.

Dans ma classe, je crée un StateObjectLink pour lier le StateObject de l’ESP dans une propriété .NET de mon code :

/// <summary>
/// StateObject du projecteur. Permet de connaitre l'uptime du projecteur.
/// </summary>
[StateObjectLink("ESP01_Projector", "Uptime")]
public StateObjectNotifier ProjectorUptime { get; set; }

Maintenant au démarrage de mon package, j’attache un « handler » sur l’événement « ValueChanged » permettant d’ajouter du code en cas de mise à jour du StateObject.

Ici je vérifie que mon StateObjectLink est bien lié au StateObject (HasValue) et que ce StateObject n’est pas expiré (IsExpired).

Si la condition est vrai, c’est que mon projecteur est allumé, alors je peux fermer mes volets autrement je restaure les volets dans leurs positions précédentes.

this.ProjectorUptime.ValueChanged += (s, e) =>
{
    // Projecteur allumé ?
    if (this.ProjectorUptime.HasValue == true && this.ProjectorUptime.Value.IsExpired == false)
    {
        // Si projecteur est allumé, on ferme les volets.
        foreach (var volet in this.voletConfig)
        {
            if (this.ShowDebug)
            {
                PackageHost.WriteWarn($"Fermeture du volet {volet.Name} à 100%.");
            }
            
            // On enregistre au passage la position de départ pour la restaurer à la fin.
            volet.PreviousPosition = volet.CurrentPosition; 
            
            // Ordre de fermeture (100%).
            PackageHost.CreateMessageScope("ESP_Shutters").ChangePercent(volet.Name, 100);
        }
    }
    else
    {
        // Si projecteur est éteint, on rouvre les volets.
        foreach (var volet in this.voletConfig)
        {
            if (this.ShowDebug)
            {
                PackageHost.WriteWarn($"Ouverture du volet {volet.Name} à l'ancienne position, {Convert.ToInt32(volet.Percent * 100.0)}->{volet.PreviousPosition}% après {this.tempoReouvertureVolets} secs d'inactivité.");
            }

            // Pour chaque volet, on revient à la position initiale
            PackageHost.CreateMessageScope("ESP_Shutters").ChangePercent(volet.Name, volet.PreviousPosition);
        }
    }
};

Conclusion

Une demi-heure de prototypage et de soudure, un petit quart d’heure de développement, et le challenge est relevé !

L’allumage du projecteur ferme les volets de mon salon selon une consigne, il déclenche également un scénario prédéfini pour les lampes Hue et active la prise du système de son. Le clic sur le bouton de la télécommande rend l’expérience du film beaucoup plus profitable avec Constellation !

The post Connecter un vidéo projecteur standard à Constellation et synchroniser les volets 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.

Actuellement, dans la version 1.0 du package, seuls les prises connectés Wemo Switch et Wemo Insight sont supportées.

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

Installation

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

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

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

<package name="Wemo" />

Détails du package

Les Settings

Les StateObjects

Vous retrouverez autant de StateObjects que périphérique Wemo découvert sur le réseau :

Les MessageCallbacks

Le package expose 3 MessageCallbacks :

Quelques exemples

• Afficher l’état et contrôler chaque des prises Wemo depuis une application mobile multi-plateforme

The post Wemo : intégrez vos prises Belkin Wemo dans Constellation appeared first on Constellation.

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

Installation

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

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 l’adresse IP (ou DNS) de votre Vera :

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

<package name="Vera">
  <settings>
    <setting key="VeraHost" value=192.168.x.x />
  </settings>
</package>

Détails du package

Les Settings

Les StateObjects

Vous retrouverez autant de StateObjects que périphérique Z-Wave enregistré sur votre Vera :

Les MessageCallbacks

Le package expose 3 MessageCallbacks :

Quelques exemples

• Afficher l’état et contrôler chaque lampe et volet sur un Dashboard HTML
• Gérer les volets automatiquement en fonction de la luminosité avec un package C#
• Piloter des lampes Hue en suivant un schéma depuis un interrupteur Fibaro grâce à un package C#
• Piloter sa domotique Z-Wave depuis un montre Samsung Gear S2
• Synchroniser la lampe du bureau avec la session Windows

The post Vera : la domotique Z-Wave dans Constellation appeared first on Constellation.