L’idée est à la fois de pouvoir allumer ou éteindre toutes les ampoules de la pièce à partir de l’interrupteur mais également de pouvoir sélectionner une ambiance lumineuse en fonction des circonstances, par exemple pour un salon : ambiance « réception », ambiance « soirée », ambiance « Ciné », ambiance « Feu de cheminée », etc…

Prérequis

• Un serveur Constellation
• Des lampes ou ampoules connectées, ici des Philips Hue
• Un interrupteur mural connecté, ici un interrupteur Legrand relié à un module Z-Wave Fibaro FGS-211
• Le SDK Constellation pour Visual Studio

Etape 1 : connecter un interrupteur mural

La première étape consiste donc à intégrer un interrupteur dans Constellation. Avec la polyvalence de la plateforme Constellation, il y a mille et une manière d’y parvenir.

Pour ma part, j’ai conservé les interrupteurs existants de la gamme Mosaic Legrand. Il s’agit pour être exacte d’un double bouton poussoir.

Pour le rendre connecté, j’ai ajouté un micro-module de la marque Fibaro spécialement conçu pour être intégré dans la boite d’encastrement juste derrière l’interrupteur.

Ce module Fibaro est un FGS-211 connecté en Z-Wave et disposant de deux relais en sortie pilotant des charges jusqu’à 1500W et de deux entrées. Dans mon cas, il n’y a aucune charge connectée sur ce module, il me sert juste de »capteur ».

Je rappelle aussi que les ampoules Philips Hue doivent être constamment alimentées en 220v de façon à être pilotable même après avoir fermé les lumières !

Le module Fibaro est simplement connecté sur le réseau électrique 220v pour son alimentation et aux deux boutons poussoir Legrand de la façon suivante :

Cela permettant d’avoir deux boutons connectés sur le même interrupteur : l’un servira pour allumer ou éteindre toutes les lumières du salon et l’autre permettra de changer la configuration lumineuse de la pièce.

Ce module Fibaro a été appairé sur mon contrôleur Z-Wave qui est une Vera Lite. Après avoir déployé le package Vera sur une des sentinelles de ma Constellation, on obtient différents StateObjects représentant l’état en temps réel de chaque device Z-Wave et des MessageCallbacks permettant de les piloter.

Les deux relais du FGS-221 sont considérés comme deux devices distincts de type « Switchs » (On ou Off). On a donc deux StateObjects dans Constellation pour représenter l’état de ces deux relais. Chacun de ces StateObjects contient la propriété « Status », un booléen indiquant si le relais est ouvert ou fermé.

On peut permuter l’état du relais informatiquement parlant par la Vera (ou par Constellation via le MessageCallback « SetSwitchState » du package Vera) ou directement en appuyant sur les boutons poussoirs.

Ainsi dès lors que l’utilisateur va appuyer sur l’un des boutons poussoirs, l’état du relais changera et donc le StateObject le représentant sera également mis à jour dans votre Constellation. On pourra donc s’abonner à ces deux StateObjects via l’API.NET, Python, Arduino ou autre pour réagir à ces changements d’état, par exemple pour allumer ou éteindre les ampoules Hue.

Etape 2 : connecter des lampes

Deuxième étape pour mener à bien notre projet : connecter des lampes dans Constellation. Il y a différentes solutions comme nous avons pu le découvrir dans cet autre tutoriel : solutions DIY, prises connectées en Wifi, RF, en Z-Wave, lampes ou ampoules connectées en Wifi, en ZeeBee, etc.. etc..

Dans mon cas, j’ai équipé les huit appliques de mon salon avec des ampoules Philips Hue.

Toutes les ampoules communiquent en ZeeBee à un pont Ethernet, nommé le bridge (à gauche de la photo ci-dessus). Grace au package Hue, vous disposez de différents MessageCallbacks pour contrôler chaque lampes Hue (état, intensité lumineuse, couleur, effet, etc..) et d’un StateObject par luminaire représentant son état en temps réel.

Etape 3 : synchroniser l’interrupteur avec les lampes

Passons au chose sérieuse, nous avons d’un côté deux StateObjects nous indiquant l’état des deux relais qu’on contrôle par les boutons poussoirs et de l’autre des MessageCallbacks nous permettant de contrôler les ampoules Hue du salon, reste juste à faire le lien !

Pour cela nous allons créer un package .NET en C# depuis Visual Studio.

Dans la classe principale (Program), nous allons ajouter deux StateObjectLinks, c’est à dire des propriétés dans notre code liées aux StateObjects représentant les états des interrupteurs :

[StateObjectLink("Vera", "Interrupteur Hue 1")]
public StateObjectNotifier InterrupteurHue1 { get; set; }

[StateObjectLink("Vera", "Interrupteur Hue 2")]
public StateObjectNotifier InterrupteurHue2 { get; set; }

Nous allons commencer par le bouton de gauche, c’est à dire l’interrupteur n°1 qui se chargera d’allumer ou d’éteindre toutes les ampoules du salon.

Pour cela nous allons attacher un « handler » qui réagira à la mise à jour du StateObject « Interrupteur Hue 1 ». Le handler commencera par vérifier que l’état à bien changé, c’est à dire que la propriété « Status » du « OldState » versus le « NewState » est bien différente (le StateObject peut être mis à jour par exemple dans le cas d’un « poll » Z-Wave à intervalle régulier sans pour autant que son Status ait changé !).

Ensuite on invoque simplement le MessageCallback « SetState » du package Hue. Le 1er argument est le n° de la lampe, 0 indiquant « toutes les lampes » et le 2ème argument est l’état (On ou Off) de la lampe. Ici on passera l’état du relais (propriété du Status).

this.InterrupteurHue1.ValueChanged += (s, e) =>
{
    if ((bool)e.OldState.DynamicValue.Status != (bool)e.NewState.DynamicValue.Status)
    {
        PackageHost.CreateMessageProxy("Hue").SetState(0, (bool)e.NewState.DynamicValue.Status);
    }
};

Ainsi dès que vous appuyez sur le bouton poussoir de gauche, le relais change d’état donc le code ci-dessus est invoqué ce qui allumera ou éteindra toutes vos lampes Hue !

Et voilà comment en quelques lignes on peut synchroniser des choses ensembles ! Au final, on obtient un interrupteur connecté pilotant plusieurs ampoules connectées.

Une fois votre package testé et validé, vous pouvez le publier dans votre Constellation et le déployer sur une de vos sentinelles (voir le guide). Simple et efficace !

Etape 4 : contrôler les ambiances lumineuses

Ce que nous avons fait jusqu’à présent est relativement simple : on synchronise simplement l’état du relais Fibaro (piloté par l’interrupteur) à l’état (state On/Off) des lampes Hue.

Le MessageCallback « SetState » allume ou éteint des lampes Hue. Dans le cas d’un allumage, les lampes reprendront leurs dernières configurations en terme de couleur et d’intensité.

Il existe d’autre MC sur ce package comme le SetColor, SetBrightness, ou le Set qui combine les 3 en un en prenant en paramètre à la fois l’état, la couleur et l’intensité.

Nous allons donc perfectionner notre package en utilisant un setting au format JSON pour décrire nos différentes ambiances lumineuses. L’interrupteur de gauche ne se contentera plus de faire un simple SetState sur chaque lampe mais appliquera la configuration dite par défaut que nous pourrons à tout moment mettre à jour dans les settings depuis la Console.

L’interrupteur n°2 quant à lui, celui de droite, servira pour appliquer la configuration suivante de façon cyclique (arrivé à la dernière, on revient au début).

Commençons d’abord par définir nos configurations lumineuses dans un setting JSON.

Créer des « configurations lumineuses »

Pour cela je vous propose de créer une page Web pour générer le setting de configuration sur base de l’état actuelle de vos lampes.

En clair, avec l’application officielle Hue, réglez vos lampes pour créer l’ambiance lumineuse souhaitée et en temps réel notre page Web générera l’objet JSON représentant votre configuration.

Nous allons simplement créer un simple page HTML en y ajoutant le module Constellation / AngularJS comme vu ici.

Lorsque nous sommes connecté, on enregistre un StateObjectLink sur tous les StateObjects du type « Q42.HueApi.Light » du package Hue. Pour chaque lampe Hue, on stocke la valeur du StateObject dans une variable de scope nommée « lights » :

constellation.registerStateObjectLink("*", "Hue", "*", "Q42.HueApi.Light", function (stateObject) { 
    $scope.$apply(function () {
        $scope.lights[stateObject.Name] = stateObject.Value;
    });
});

Ainsi l’état de chacune de nos lampes sera synchronisée en temps réel dans cette variable Javascript.

Maintenant dans le code HTML, générons une liste pour afficher le nom de chaque lampe, son ID, son état (on/off), sa couleur (Hue et Saturation) et son intensité (bri) avec un « ng-repeat » Angular :

<ul>
    <li ng-repeat="(name, value) in lights" title="{{value}}">{{name}} = #{{value.id}} On:{{value.state.on}} Hue:{{value.state.hue}} Sat:{{value.state.sat}} Bri:{{value.state.bri}}</li>
</ul>

C’est aussi simple que cela !

Maintenant ajoutons une méthode « ExportCurrentConfig » qu’on appellera dans notre StateObjectLink dès qu’un StateObject est mis à jour :

$scope.ExportCurrentConfig = function() {
    var config = { ConfigName: "MyConfig", Lights: []};
    for(var name in $scope.lights) {
        var value = $scope.lights[name];
        config.Lights.push({ id: value.id, state: value.state.on, hue: value.state.hue, sat:value.state.sat, bri:value.state.bri });
    }
    $scope.strConfigs = JSON.stringify([ config ]).replace(/"/g, "'");
};

On crée un objet avec une propriété « ConfigName » pour nommer notre configuration et un tableau « Lights » qu’on remplit avec l’état connu de chaque lampe. Pour finir on « stringify » notre objet en JSON qu’on affichera ensuite dans un « textarea » sur la page :

Il ne reste plus qu’à générer différentes configurations notre « extracteur » pour la suite de notre tutoriel.

Le code complet de la page :

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" ng-app="hue">
<head>
    <title>Hue Configuration</title>
        
    <script type="text/javascript" src="/Scripts/jquery-2.1.3.min.js"></script>
    <script type="text/javascript" src="/Scripts/angular.min.js"></script>
    <script type="text/javascript" src="/Scripts/jquery.signalR-2.2.0.min.js"></script>
    <script type="text/javascript" src="/Scripts/Constellation-1.8.1.js"></script>
    <script type="text/javascript" src="/Scripts/ngConstellation-1.8.1.js"></script> 
    
    <script>
        var hue = angular.module('hue',  ['ngConstellation'])
            .controller('HueController', ['$scope', 'constellationConsumer', function ($scope, constellation) {
                $scope.lights = {};
                $scope.strConfigs = "";
            
                constellation.initializeClient("http://xxxxxxx:8088/", "demo123", "Hue Configurator");
                
                $scope.ExportCurrentConfig = function() {
                    var config = { ConfigName: "MyConfig", Lights: []};
                    for(var name in $scope.lights) {
                        var value = $scope.lights[name];
                        config.Lights.push({ id: value.id, state: value.state.on, hue: value.state.hue, sat:value.state.sat, bri:value.state.bri });
                    }
                    $scope.strConfigs = JSON.stringify([ config ]).replace(/"/g, "'");
                };

                constellation.onConnectionStateChanged(function (change) {
                    if (change.newState === $.signalR.connectionState.connected) {
                        console.log("Connected");
                        constellation.registerStateObjectLink("*", "Hue", "*", "Q42.HueApi.Light", function (stateObject) {  
                            $scope.$apply(function () {
                                $scope.lights[stateObject.Name] = stateObject.Value;    
                                $scope.ExportCurrentConfig();
                            });
                        });                        
                    }
                    else if (change.newState === $.signalR.connectionState.disconnected) {    
                        constellation.connect();
                    }
                });
                
                constellation.connect();
            }]);
    </script>
</head>
<body>
    <ul>
        <li ng-repeat="(name, value) in lights" title="{{value}}">{{name}} = #{{value.id}} On:{{value.state.on}} Hue:{{value.state.hue}} Sat:{{value.state.sat}} Bri:{{value.state.bri}}</li>
    </ul>
    <hr/>
    <p>Current configuration :</p>
    <textarea rows="40" cols="50">{{strConfigs}}</textarea>
    
</body>
</html>

Activer les configurations depuis interrupteur

Premièrement nous allons déclarer dans le manifeste de notre package (PackageInfo.xml) le setting « Hue.Configuration » par la ligne :

<Setting name="Hue.Configurations" type="JsonObject" isRequired="true" description="Configurations lumineuses" />

Le contenu de ce setting sera un tableau des différentes configurations générées par notre extracteur ci-dessus.

Pour ma part voici mes configurations à titre d’exemple :

[
   {
      'ConfigName':'Blanc chaud',
      'DefaultConfig':true,
      'Lights':[
         {
            'id':'1',
            'state':true,
            'hue':6479,
            'sat':252,
            'bri':254
         },
         {
            'id':'2',
            'state':true,
            'hue':13907,
            'sat':187,
            'bri':179
         },
         {
            'id':'3',
            'state':true,
            'hue':13907,
            'sat':187,
            'bri':254
         },
         {
            'id':'4',
            'state':true,
            'hue':14101,
            'sat':180,
            'bri':141
         },
         {
            'id':'5',
            'state':true,
            'hue':14101,
            'sat':180,
            'bri':254
         },
         {
            'id':'6',
            'state':true,
            'hue':14101,
            'sat':180,
            'bri':161
         },
         {
            'id':'7',
            'state':true,
            'hue':12778,
            'sat':219,
            'bri':120
         },
         {
            'id':'8',
            'state':true,
            'hue':12778,
            'sat':219,
            'bri':254
         }
      ]
   },
   {
      'ConfigName':'Film du soir',
      'Lights':[
         {
            'id':'1',
            'state':true,
            'hue':7157,
            'sat':243,
            'bri':104
         },
         {
            'id':'2',
            'state':false,
            'hue':13907,
            'sat':187,
            'bri':179
         },
         {
            'id':'3',
            'state':true,
            'hue':13122,
            'sat':211,
            'bri':80
         },
         {
            'id':'4',
            'state':true,
            'hue':12778,
            'sat':219,
            'bri':142
         },
         {
            'id':'5',
            'state':true,
            'hue':13122,
            'sat':211,
            'bri':80
         },
         {
            'id':'6',
            'state':false,
            'hue':14101,
            'sat':180,
            'bri':161
         },
         {
            'id':'7',
            'state':false,
            'hue':13122,
            'sat':211,
            'bri':120
         },
         {
            'id':'8',
            'state':false,
            'hue':4712,
            'sat':241,
            'bri':254
         }
      ]
   },
   {
      'ConfigName':'Cheminée',
      'Lights':[
         {
            'id':'2',
            'state':false,
            'hue':7980,
            'sat':252,
            'bri':79
         },
         {
            'id':'8',
            'state':true,
            'hue':4712,
            'sat':241,
            'bri':254
         },
         {
            'id':'5',
            'state':true,
            'hue':13122,
            'sat':211,
            'bri':91
         },
         {
            'id':'4',
            'state':false,
            'hue':7862,
            'sat':252,
            'bri':53
         },
         {
            'id':'3',
            'state':true,
            'hue':13122,
            'sat':211,
            'bri':91
         },
         {
            'id':'6',
            'state':true,
            'hue':8774,
            'sat':252,
            'bri':56
         },
         {
            'id':'7',
            'state':true,
            'hue':13122,
            'sat':211,
            'bri':120
         },
         {
            'id':'1',
            'state':true,
            'hue':6196,
            'sat':247,
            'bri':104
         }
      ]
   },
   {
      'ConfigName':'Tout éteind',
      'OffConfig':true,
      'Lights':[
         {
            'id':'1',
            'state':false,
            'hue':7157,
            'sat':243,
            'bri':104
         },
         {
            'id':'2',
            'state':false,
            'hue':13907,
            'sat':187,
            'bri':179
         },
         {
            'id':'3',
            'state':false,
            'hue':3584,
            'sat':252,
            'bri':254
         },
         {
            'id':'4',
            'state':false,
            'hue':12778,
            'sat':219,
            'bri':142
         },
         {
            'id':'5',
            'state':false,
            'hue':13122,
            'sat':211,
            'bri':80
         },
         {
            'id':'6',
            'state':false,
            'hue':14101,
            'sat':180,
            'bri':161
         },
         {
            'id':'7',
            'state':false,
            'hue':12778,
            'sat':219,
            'bri':120
         },
         {
            'id':'8',
            'state':false,
            'hue':12778,
            'sat':219,
            'bri':254
         }
      ]
   }
]

Vous remarquerez que j’ai ajouté sur la première configuration la propriété « DefaultConfig = true » et « OffConfig =true » sur la dernière.  On se servira de ces deux propriétés pour savoir quelles sont les configurations à appliquer en cas de « On » et de « Off » sur notre interrupteur n°1.

Le setting est de type « JsonObject », on aura donc un bel éditeur dans la Console Constellation pour le déclarer ou le modifier. Pour vos développements vous pouvez aussi utiliser le fichier App.config.

Pour revenir à notre code C#, nous allons tout d’abord déclarer les variables privées suivantes :

private int currentConfigurationId = 0, defaultConfigurationId = 0, offConfigurationId = 0;
private List<dynamic> hueConfiguration = new List<dynamic>();

Dans la méthode démarrage (OnStart) on charge notre setting JSON dans la variable « hueConfiguration » avec la méthode « GetSettingAsJson » puis on récupère dans ce tableau l’index de la configuration « Default » et « Off » par la méthode .NET « FindIndex » :

hueConfiguration = new List<dynamic>(PackageHost.GetSettingAsJsonObject("Hue.Configurations"));
defaultConfigurationId = this.hueConfiguration.FindIndex(c => c.DefaultConfig == true);
offConfigurationId = this.hueConfiguration.FindIndex(c => c.OffConfig == true);

Créons maintenant la méthode « ApplyHueConfiguration » qui se chargera d’appliquer la configuration sur nos lampes Hue.

En quelques mots elle itère sur chaque « Light » de la configuration spécifiée par son index puis invoque le MessageCallback « Set » du package Hue en passant l’ID de la lampe avec son état (state, hue/sat et brightness). La configuration courante est sauvegardée dans la variable « currentConfigurationId« .

Il est aussi possible de spécifier optionnellement l’index de la configuration à exclure ce qui aura pour action d’appliquer automatique la configuration suivante.

private int ApplyHueConfigration(List<dynamic> configurationList, int configIdx, int configToExclude = -1)
{
    // Si la config selectionnée est à exclure ...
    if (configToExclude >= 0 && configIdx == configToExclude)
    {
        // On passe à la configuration suivante :
        return this.ApplyHueConfigration(configurationList, (configIdx + 1) % configurationList.Count, configToExclude);
    }
    else
    {
        // On récupere la configuration à partir de son Index
        var config = configurationList[configIdx];
        PackageHost.WriteInfo("Applying Hue configuration '{0}'", config.ConfigName);
        // On applique la configuration en invoquant le MC "Set" à chaque lampe
        this.currentConfigurationId = configIdx;
        foreach (dynamic hue in config.Lights)
        {
            PackageHost.CreateMessageProxy("Hue").Set(hue.id, hue.state, hue.hue, hue.sat, hue.bri);
            Thread.Sleep(100);
        }
        // On retourne l'Index de la configuration appliquée
        return configIdx;
    }
}

Maintenant modifions notre handler sur le StateObjectLink « InterrupteurHue1 » que nous avons créé précédemment.

Dès que cet interrupteur change d’état on applique la configuration « Default » ou « Off » en fonction de l’état du relais FGS-211 correspondant. On prendra garde de ne rien faire si l’interrupteur change à « On » alors que l’état des lampes n’est pas éteint et inversement, on ne fera rien si l’interrupteur change à « Off » alors que les lampes sont déjà éteintes.

this.InterrupteurHue1.ValueChanged += (s, e) =>
{
    // Si InterrupteurHue1 change d'état
    if ((bool)e.OldState.DynamicValue.Status != (bool)e.NewState.DynamicValue.Status)
    {
        if ((bool)e.NewState.DynamicValue.Status && this.currentConfigurationId != offConfigurationId)
        {
            // Ne rien faire si InterrupteurHue1 = ON et que la configuration actuelle n'est pas "tout eteint" !
            return;
        }
        else if ((bool)e.NewState.DynamicValue.Status == false && this.currentConfigurationId == offConfigurationId)
        {
            // Ne rien faire si InterrupteurHue1 = OFF et que la configuration actuelle est déjà "tout eteint" !
            return;
        }
        else
        {
            // Autrement on applique la configuration "default" si InterrupteurHue1 = ON ou "off" si InterrupteurHue1 = Off
            this.ApplyHueConfigration(hueConfiguration, (bool)e.NewState.DynamicValue.Status ? defaultConfigurationId : offConfigurationId);
        }
    }
};

Maintenant pour le deuxième interrupteur, dès qu’il changera d’état, deux cas :

• Si l’interrupteur n°1 n’est pas allumé, on invoque le MC « SetSwitchState » du package Vera pour l’allumer. Ainsi son SO sera mis à jour et donc le code ci-dessus sera invoqué pour appliquer la configuration « Default » (synchronisation parfaite entre l’état du relais Fibaro et nos lampes)
• Si l’interrupteur n°1 est déjà allumé, on appelle notre méthode « ApplyHueConfiguration » en spécifiant l’index de la prochaine configuration et en excluant la configuration « tout éteint » (Off)

// On permute les configurations avec InterrupteurHue2
this.InterrupteurHue2.ValueChanged += (s, e) =>
{
    // Si InterrupteurHue2 change d'état
    if ((bool)e.OldState.DynamicValue.Status != (bool)e.NewState.DynamicValue.Status)
    {
        // Si InterrupteurHue1 = OFF, on l'allume pour garder InterrupteurHue1 syncrhonisé !
        if ((bool)this.InterrupteurHue1.DynamicValue.Status == false)
        {
            // Cela déclenchera le handler ci-dessus ce qui appliquera la configuration "default".
            PackageHost.CreateMessageProxy("Vera").SetSwitchState(new { DeviceID = (int)this.InterrupteurHue1.DynamicValue.Id, State = true });
        }
        else // Si InterrupteurHue1 est déjà ON
        {
            // ON applique la configuration suivante de facon cyclique en excluant la configuration " tout éteint"
            this.ApplyHueConfigration(hueConfiguration, (this.currentConfigurationId + 1) % hueConfiguration.Count, configToExclude: offConfigurationId);
        }
    }
};

Ainsi on a bien l’interrupteur n°1 qui contrôle le relais n° 1 du Fibaro, lui même parfaitement synchronisé avec nos lampes. Si le relais est éteint, on applique la configuration « OffConfig » de notre setting et si le relais est allumé, on applique la configuration « DefaultConfig ».

Quand on appuie sur l’interrupteur n°2, on permute l’état du relais n° 2 du Fibaro ce qui applique donc, de manière cyclique, les différentes configurations de notre setting sur nos lampes Hue.

On peut modifier comme bon nous semble le setting depuis la Console Constellation pour changer la configuration par défaut, ajouter ou supprimer de nouvelles ambiances ou modifier celles existantes ! De même, si ajoutez des lampes dans votre pièce vous n’aurez qu’à les déclarer dans votre JSON;

De plus, avec n’importe quelle application ou contrôleur Z-Wave comme un Minimote par exemple, vous pouvez contrôler l’interrupteur n°1 qui se synchronisera parfaitement avec vos lampes Hue !

Pour aller plus loin

Ajoutons une dernière méthode nommée « ApplyHueConfiguration » qui accepte en paramètre le nom de la configuration à appliquer. On l’invoque avec le nom de la configuration (et non l’index) et elle se chargera d’appliquer cette configuration si elle existe bien dans votre setting.

Une fois n’est pas coutume, on enverra des messages au package Vera pour synchroniser l’état du relais n°1 si nécessaire.

[MessageCallback]
public int ApplyHueConfigration(string configName)
{
    // On récupere l'ID de la configuration à partir de son nom
    int configId = this.hueConfiguration.FindIndex(c => c.ConfigName == configName);
    if (configId >= 0)
    {
        // On synchronise l'interrupteur Fibaro avec les lampes (sens Hue -> Fibaro)
        if (configId != offConfigurationId && (bool)this.InterrupteurHue1.DynamicValue.State == false)
        {
            PackageHost.CreateMessageProxy("Vera").SetSwitchState(new { DeviceID = (int)this.InterrupteurHue1.DynamicValue.Id, State = true });
        }
        else if (configId == offConfigurationId && (bool)this.InterrupteurHue1.DynamicValue.State == true)
        {
            PackageHost.CreateMessageProxy("Vera").SetSwitchState(new { DeviceID = (int)this.InterrupteurHue1.DynamicValue.Id, State = false });
        }

        // On applique la configuration
        return this.ApplyHueConfigration(hueConfiguration, configId);
    }
    else
    {
        return configId;
    }
}

Vous remarquerez que nous avons ajouté l’attribut [MessageCallback] sur cette méthode ce qui veut dire que votre package exposera cette méthode, que l’on nomme MessageCallback, pour toute votre Constellation.

C’est à dire que n’importe quel autre package C#, Python, un script Powershell ou Bash, un Arduino ou ESP8266, une page Web, etc… Tous pourront envoyer un message à votre package pour appliquer des configurations lumineuses sur vos lampes Hue en fonction des configurations que nous avez configuré dans votre setting !

The post Synchroniser un interrupteur mural avec des ampoules connectées et contrôler l’ambiance lumineuse de votre pièce appeared first on Constellation.

L’idée est très simple : lorsque vous déverrouillez (ou ouvrez) votre session Windows on allumera automatiquement la lampe du bureau et lorsque vous verrouillez (ou fermez) votre session, la lampe s’éteindra automatiquement.

On peut même aller plus loin si vous avez un capteur de luminosité connecté pour n’allumer la lampe que lorsqu’il fait trop sombre.

Prérequis

• Un serveur Constellation
• Une lampe pilotable par Constellation
• Le package WindowsControl déployé sur la sentinelle de l’ordinateur Windows à synchroniser avec la lampe
• Optionnellement un capteur de luminosité connecté dans Constellation
• Le SDK Constellation pour Visual Studio

Etape 1 : piloter une lampe par Constellation

Bien entendu il faut d’abord pouvoir piloter une lampe par Constellation pour réaliser ce tutoriel !

Vous pouvez par exemple piloter un relais depuis un Raspberry en créant un package Python ou bien depuis un Arduino ou un ESP8266 comme vu dans ce tutoriel. Il suffit de créer une fonction pilotant un relais (simple manipulation d’une sortie digitale) et d’exposer cette fonction comme MessageCallback. On pourra ainsi invoquer votre méthode pour ouvrir et fermer le relais et donc piloter une lampe depuis n’importe quel système connecté dans votre Constellation.

Autre solution utiliser une carte de relais connectée par USB qu’on pilotera avec le package RelayBoard. Ce package expose des MC permettant d’ouvrir ou fermer les relais et publie l’état de chacun d’entre eux comme StateObject. Il ne reste plus qu’à connecter une lampe sur l’un des relais.

On peut aussi utiliser des prises Wifi Belkin Wemo qu’on connectera à Constellation avec le package Wemo. Encore une fois ce package expose des MC permettant d’allumer ou d’éteindre la charge connectée dessus et publie son état en tant que StateObject. Il suffit d’y brancher une lampe !

Dans la même idée, on peut utiliser des prises Somfy qu’on connectera à Constellation avec le package RFXCOM nécessitant une passerelle RFXcom connectée en USB. Le package expose un MessageCallback permettant d’envoyer des ordres par radiofréquences aux équipements RTS (protocole Somfy) pour piloter par exemple des prises. Il n’y a pas de retour d’état sur ce protocole, donc il ne sera pas possible de récupérer son état mais on pourra allumer ou éteindre la prise et donc une lampe !

Encore une autre possibilité, utiliser des prises ou des modules Z-Wave. Il faut pour cela un contrôleur Z-Wave qu’on connectera à Constellation. Vous pouvez soit utiliser le package Jeedom ou soit le package Vera.

On pourrait également utiliser des lampes ou des ampoules connectées de la gamme Phillips Hue qu’on connectera à Constellation grâce au package Hue.

Pour ma part la lampe de mon bureau est contrôlée par une prise Z-Wave AN158 appairée sur une Vera Lite. Ce contrôleur Z-Wave est connecté à Constellation grâce au package Vera.

J’ai donc dans ma Constellation des StateObjets pour chaque périphérique Z-Wave et des MessageCallbacks pour envoyer des ordres Z-Wave. Par exemple depuis le MessageCallbacks Explorer, on retrouve le MC « SetSwitchState » permettant de définir l’état d’un switch (On/Off) Z-Wave.

Depuis l’API.net il me suffit d’invoquer le code suivant pour allumer le device #42 :

PackageHost.CreateMessageProxy("Vera").SetSwitchState(new { DeviceID = 42, State = true });

Vous pouvez appuyer sur le bouton  pour obtenir les exemples de code pour chaque MessageCallback. Par exemple toujours pour allumer le device Z-Wave #42 depuis un Arduino :

constellation.sendMessage(Package, "Vera", "SetSwitchState", "{ 'DeviceID':42, 'State':true }");

Bref il existe différente méthode de piloter une lampe (ou n’importe quelle charge) depuis Constellation, soit en mode DIY en créant vous-même votre package réel (C#, Python, …) ou virtuel (Arduino, ESP8266, Gadgeteer, …) ou bien en utilisant des technologies telles RTS de Somfy, le Z-Wave, les lampes et ampoules Philips, les prises Wifi de Belkin, etc… avec les packages déjà disponibles dans le catalogue en ligne.

Et quand bien même il n’existe pas de connecteur Constellation pour piloter votre lampe, libre à vous de créer votre propre package créant ainsi la passerelle, le connecteur entre Constellation et votre lampe.

Etape 2 : connaitre l’état de la session avec le package WindowsControl

Maintenant que nous avons un MessageCallback pour piloter la lampe du bureau, faut-il encore savoir si la session est ouverte ou non.

Pour cela vous avez dans le catalogue en ligne, le package WindowsControl qui expose différent MessageCallbacks pour verrouiller ou fermer une session, pour arrêter ou redémarrer l’ordinateur, pour contrôler le volume ou la luminosité (comme vu dans ce tutoriel).

Ce package produit également un StateObject nommé « SessionLocked » de type booléen qui indique si la session est verrouillée (ou fermée) ou non.

Il suffit donc de déployer ce package depuis la Console Constellation sur la sentinelle UI du PC à synchroniser avec votre lampe. On suivra ainsi ce StateObject pour savoir quel est l’état de votre session et réagir tout changement d’état.

Etape 3 : synchroniser la lampe avec la session en C#

Passons au chose sérieuse, nous avons d’un côté un StateObject nous indiquant si la session est ouverte ou non et un MessageCallback nous permettant d’allumer ou d’éteindre la lampe du bureau, reste juste à créer le lien.

Pour cela nous allons créer un package .NET en C# depuis Visual Studio.

Dans la classe principale (Program), nous allons ajouter un StateObjectLink, c’est à dire une propriété dans notre code liée au StateObject représentant l’état de la session en ajoutant les lignes :

[StateObjectLink("WindowsControl", "SessionLocked")]
public StateObjectNotifier SessionLocked { get; set; }

Prenez garde toutefois, si vous avez déployé le package WindowsControl sur plusieurs sentinelles de votre Constellation, le StateObjectLink ci-dessus sera lié à plusieurs StateObjects et non au StateObject de votre ordinateur à scruter. L’unicité d’un StateObject est obtenu par le triplet : “Sentinel + Package + Nom” car un nom de StateObject est unique pour une instance de package (couple Sentinel / Package), de même qu’un package est unique pour une sentinelle et qu’une sentinelle est unique dans une Constellation.

De ce fait pour lier la propriété « SessionLocked » au StateObject « SessionLocked » de votre ordinateur on écrira :

[StateObjectLink("PC-SEB_UI", "WindowsControl", "SessionLocked")]
public StateObjectNotifier Session { get; set; }

Dans l’exemple ci-dessus, la machine est nommée « PC-SEB » et donc le nom de sa sentinelle « PC-SEB_UI » étant donné que le package WindowsControl est déployé sur la Sentinelle UI d’où le suffixe « _UI » dans le nom de la sentinelle. Vous pouvez bien entendu vérifier le nom exacte de votre sentinelle sur la Console Constellation.

Maintenant que l’état de la session de notre PC est synchronisé dans cette propriété .NET de notre code C#, nous allons ajouter un « handler » pour réagir au changement d’état :

this.SessionLocked.ValueChanged += (s, e) =>
{
    if ((bool)this.SessionLocked.DynamicValue)
    {
        PackageHost.WriteInfo("Verrouillage de la session : fermeture de la lampe");
    }
    else
    {
        PackageHost.WriteInfo("Session déverrouillée : allumage de la lampe");
    }
};

Maintenant pour allumer la lumière, il suffit d’envoyer un message pour déclencher le MessageCallback permettant de contrôler votre lampe. Comme expliqué ci-dessus, dans mon cas, la lampe sur mon bureau est contrôlée par une prise Z-Wave AN158 pilotable par le package Vera via le MessageCallback « SetSwitchState« .

On crée donc un proxy dynamique vers le package Vera et on invoque le MC comme on invoquerait une méthode .NET en passant en paramètre un objet contenant l’ID du device Z-Wave et l’état souhaité :

PackageHost.CreateMessageProxy("Vera").SetSwitchState(new { DeviceID = 42, State = true });

Pour connaitre l’ID du device Z-Wave on peut soit le rechercher dans le StateObjects Explorer et l’écrire en dur dans notre code C#, ou soit ajouter un autre StateObjectLink afin de récupérer dynamiquement son Id (car contenu dans le StateObject du device).

Le code de notre package sera donc :

public class Program : PackageBase
{
    [StateObjectLink("Vera", "Lampe Bureau Seb")]
    public StateObjectNotifier LampeBureau { get; set; }

    [StateObjectLink("PC-SEB_UI", "WindowsControl", "SessionLocked")]
    public StateObjectNotifier SessionLocked { get; set; }

    static void Main(string[] args)
    {
        PackageHost.Start<Program>(args);
    }

    public override void OnStart()
    {
        this.SessionLocked.ValueChanged += (s, e) =>
        {
            if ((bool)this.SessionLocked.DynamicValue)
            {
                PackageHost.WriteInfo("Verrouillage de la session : fermeture de la lampe");
                PackageHost.CreateMessageProxy("Vera").SetSwitchState(new { DeviceID = (int)this.LampeBureau.DynamicValue.Id, State = false });
            }
            else
            {
                PackageHost.WriteInfo("Session déverrouillée : allumage de la lampe");
                PackageHost.CreateMessageProxy("Vera").SetSwitchState(new { DeviceID = (int)this.LampeBureau.DynamicValue.Id, State = true });
            }
        };
    }
}

On peut maintenant lancer notre package en mode « Debug On Constellation » pour le tester depuis Visual Studio tout en le connectant dans votre Constellation :

Vous pouvez tester le fonctionnel de votre package : on verrouille la session, la lampe s’éteint, on la déverrouille, la lampe s’allume !

Une fois votre package testé et validé, vous pouvez le publier dans votre Constellation et le déployer sur une de vos sentinelles (voir le guide).

Etape 4 : ajouter un capteur de luminosité

Jusqu’à présent dès que la session est déverrouillée la lampe du bureau s’allume et dès qu’on la ferme elle s’éteint. Seulement en pleine journée ce n’est peut être pas très judicieux d’allumer la lumière !

Pour cela nous pouvons ajouter une condition supplémentaire basée sur la luminosité ambiante.

On pourrait utiliser un capteur sans fil du marché comme le Chacon DIO54783 connecté via le package RFXcom ou bien un capteur Z-Wave via le package Vera ou Jeedom. On peut aussi concevoir son propre capteur avec un Arduino ou un ESP8266 comme vu dans ce tutoriel ou avec un Raspberry Pi comme vu ici.

Dans notre article, prenons par exemple l’un des deux capteurs ci-dessus qui publient chacun un StateObject nommé « Lux » composé de 3 propriétés : Broadband, IR et Lux.

Pour intégrer cette « information » dans notre code C#, ajoutons un StateObjectLink vers le StateObject « Lux » :

[StateObjectLink("LightSensor", "Lux")]
public StateObjectNotifier LuxSensor { get; set; }

On peut maintenant modifier la condition d’allumage avec un « else if » qui vérifiera que la luminosité est inférieure à un seuil qu’on va déclarer dans les settings Constellation de façon à pouvoir modifier cette valeur à la volée depuis la Console Constellation :

else if (this.LuxSensor.DynamicValue.Lux < PackageHost.GetSettingValue<int>("DaylightThreshold"))

Bien entendu comme tout setting, il est vivement recommandé de le déclarer dans le manifeste du package (le fichier PackageInfo.xml). De plus on pourra y définir la valeur par défaut ici fixée à 50 (lux) :

<Settings>
  <Setting name="DaylightThreshold" type="Int32" defaultValue="50" description="Seuil de luminosité minimale pour l'allumage de la lampe du bureau" />
</Settings>

Pour finir, prenons le cas où la session est déjà déverrouillée et la soirée arrivant, la luminosité passe en dessous du seuil : il faut alors allumer la lumière bien que l’état de la session n’a pas changé !

Pour cela nous allons ajouter un « handler » pour réagir à chaque mise à jour du StateObject « Lux » du capteur de luminosité. A chaque nouvelle mesure, si la valeur est inférieure au seuil défini dans les settings et que la session est bien déverrouillée, on allumera la lumière :

this.LuxSensor.ValueChanged += (s, e) =>
{
    if (e.NewState.DynamicValue.Lux < PackageHost.GetSettingValue<int>("DaylightThreshold") && (bool) this.SessionLocked.DynamicValue == false)
    {
        PackageHost.WriteInfo("Session déverrouillée à la tombée de la nuit : allumage de la lampe");
        PackageHost.CreateMessageProxy("Vera").SetSwitchState(new { DeviceID = (int)this.LampeBureau.DynamicValue.Id, State = true });
    }
};

Ainsi notre lumière de bureau est maintenant synchronisée à notre session et ne s’allumera que si la luminosité est faible. Elle sera donc éteinte dès qu’on ferme ou verrouille la session et s’allumera si la luminosité baisse sous le seuil défini dans les settings alors que la session est déjà déverrouillée ou vient d’être déverrouillée.

Etape 5 : fermer la lampe en cas de déconnexion du PC

Pour vraiment aller au fond des choses il y a encore un cas à gérer : que faire si le PC s’arrête proprement ou brutalement. En somme l’idée est de fermer la lampe si le PC est déconnecté de Constellation, que ce soit suite à un arrêt de l’ordinateur, un crash, une déconnexion quelconque, etc..

Pour savoir si le PC est bien connecté on va surveiller l’état de la sentinelle UI de votre PC. Pour cela il faut se connecter sur le hub de contrôle.

L’utilisation du hub de contrôle depuis un package C# est expliqué en détail dans cet article que je vous recommande de lire.

La première étape consiste donc à déclarer dans le manifeste du package (le fichier PackageInfo.xml) l’utilisation du hub de contrôle par votre package en ajoutant l’attribut suivant sur la balise Package :

EnableControlHub="true"

De plus il faut également, sur votre package, définir une clé d’accès ayant les droits d’accès au hub de contrôle. Vous pouvez vérifier la bonne connexion au hub de contrôle dans votre code par la propriété : « PackageHost.HasControlManager« .

Une fois connecté au hub de contrôle on va demander à recevoir les mises à jour des statuts des sentinelles de notre Constellation par la ligne :

PackageHost.ControlManager.RequestSentinelUpdates();

Cela nous permet ensuite d’attacher un « handler » qu’on filtrera sur notre sentinelle (ici nommée « PC-SEB_UI »). On stockera dans la variable « pcConnected » un booléen indiquant si la sentinelle de notre PC est connectée ou non. Si notre sentinelle n’est pas/plus connectée, on fermera immédiatement la lampe du bureau.

PackageHost.ControlManager.SentinelUpdated += (s, e) =>
{
    if (e.Sentinel.Description.SentinelName == "PC-SEB_UI")
    {
        this.pcConnected = e.Sentinel.IsConnected;
        PackageHost.WriteInfo("Le PC de Seb est '{0}'", e.Sentinel.IsConnected ? "connecté" : "déconnecté");
        if (!this.pcConnected)
        {
            // Éteindre la lampe si le PC est déconnecté !
            PackageHost.CreateMessageProxy("Vera").SetSwitchState(new { DeviceID = (int)this.LampeBureau.DynamicValue.Id, State = false });
        }
    }
};

De plus, dans la condition d’allumage, on rajoutera le fait de vérifier que le PC est bien connecté avant de prendre la décision d’allumer la lampe :

else if (this.pcConnected && this.LuxSensor.DynamicValue.Lux < PackageHost.GetSettingValue<int>("DaylightThreshold"))

Et voilà, notre package est opérationnel ! La lampe est parfaitement synchronisée avec l’état de notre session Windows en tenant compte de la luminosité ambiante et des différents cas de figure pouvant apparaître, comme le redémarrage, l’arrêt ou le crash de notre PC !

Le code final est :

public class Program : PackageBase
{
    // Nom de la sentinelle Windows à syncrhoniser avec la lampe
    private const string SEB_PC_SENTINEL_NAME = "PC-SEB_UI";
    
    // PC Connecté? oui ou non !
    private bool pcConnected = false;

    // Lien vers le SO de la lampe du bureau
    [StateObjectLink("Vera", "Lampe Bureau Seb")]
    public StateObjectNotifier LampeBureau { get; set; }

    // Lien vers l'état de la session Windows
    [StateObjectLink(SEB_PC_SENTINEL_NAME, "WindowsControl", "SessionLocked")]
    public StateObjectNotifier SessionLocked { get; set; }

    // Lien vers le capteur de luminosité
    [StateObjectLink("LightSensor", "Lux")]
    public StateObjectNotifier LuxSensor { get; set; }

    // Démarrage du package
    static void Main(string[] args)
    {
        PackageHost.Start<Program>(args);
    }

    // Méthode de démarrage de notre package
    public override void OnStart()
    {
        // Si accès au ControlHub
        if (PackageHost.HasControlManager)
        {
            // Demande de reception des mise à jour des sentinelles
            PackageHost.ControlManager.RequestSentinelUpdates();
            // En cas de mise à jour de l'état d'une sentinelle
            PackageHost.ControlManager.SentinelUpdated += (s, e) =>
            {
                // Si cela concerne notre sentinelle
                if (e.Sentinel.Description.SentinelName == SEB_PC_SENTINEL_NAME)
                {
                    // On stocke dans la variable "pcConnected" l'état connecté ou déconnecté de notre PC
                    this.pcConnected = e.Sentinel.IsConnected;
                    PackageHost.WriteInfo("Le PC de Seb est '{0}'", e.Sentinel.IsConnected ? "connecté" : "déconnecté");
                    // Si le PC est maintenant déconnecté, on ferme la lampe !
                    if (!this.pcConnected)
                    {
                        SetLight(false);
                    }
                }
            };
        }
        else
        {
            // Pas d'accès au COntrolHub, on log une erreur ! Vérifiez votre clé d'accès !
            PackageHost.WriteError("Accès au ControlHub impossible !");
        }

        // En cas de mise à jour du StateObject "Lux" du package "LightSensor"
        this.LuxSensor.ValueChanged += (s, e) =>
        {
            // Si le PC est connecté, que la luminosité actuelle est inférieure au seuil défini dans les settings et que la session est bien dévérouillée
            if (this.pcConnected && e.NewState.DynamicValue.Lux < PackageHost.GetSettingValue<int>("DaylightThreshold") && (bool) this.SessionLocked.DynamicValue == false)
            {
                // On allume la lampe !
                SetLight(true);
                PackageHost.WriteInfo("Session dévérouillée à la tombée de la nuit : allumage de la lampe");
            }
        };

        // En cas de mise à jour du StateObject "SessionLocked" du package "WindowsControl"
        this.SessionLocked.ValueChanged += (s, e) =>
        {
            // Si la session est vérouillée (ou fermée)
            if ((bool)this.SessionLocked.DynamicValue)
            {
                // On eteint la lampe
                SetLight(false);
                PackageHost.WriteInfo("Verrouillage de la session : fermeture de la lampe");
            }
            // Si le PC est connecté, que la luminosité actuelle est inférieure au seuil défini dans les settings et que la session est donc dévérouillée
            else if (this.pcConnected && this.LuxSensor.DynamicValue.Lux < PackageHost.GetSettingValue<int>("DaylightThreshold"))
            {
                // On allume la lampe !
                SetLight(true);
                PackageHost.WriteInfo("Session déverrouillée avec luminosité faible : allumage de la lampe");
            }
        };
    }

    private void SetLight(bool state)
    {
        // Pour allumer la lumière, on invoque le MC "SetSwitchState" du package "Vera" en passant l'ID de la lampe (récupérée par son StateObjet)
        PackageHost.CreateMessageProxy("Vera").SetSwitchState(new { DeviceID = (int)this.LampeBureau.DynamicValue.Id, State = state });
    }
}

The post Synchroniser la lampe du bureau avec sa session Windows 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.