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.

Nous assemblerons l’ESP8266 et le capteur de luminosité TSL2561 dans une prise 220v avec un convertisseur 220v -> 3v3.

Prérequis

• Un serveur Constellation
• Un ESP8266 comme l’ESP-01 (entre 1,5€ et 2€)
• Un capteur de luminosité TSL2561 (environ 2€)
• Un convertisseur 220v -> 3v3 (environ 2€)
• Un boitier/prise 220v (entre 5 et 15 €)

Le montage

Le capteur TSL2561 se connecte en I²C, il suffit donc de l’alimenter en 3v3 et de connecter les deux GPIO de l’ESP-01 (GPIO-0 et GPIO-2) aux pins SCL et SDA du capteur.

Le schéma de connexion est donc le suivant :

Sur le bornier 220v de notre prise nous allons souder deux fils (la phase et le neutre) vers l’entrée convertisseur 220v AC. En sortie du convertisseur, on a une tension de 3v3 DC que nous connecterons à l’ESP-01 ainsi qu’au TSL2561.

N’oubliez pas également de relier le port « CH_PD » de l’ESP-01 au 3v3 pour activer le Wifi.

Pour plus d’information, je vous invite à lire cet article.

Disposez les différents composants dans le boitier en prenant soin d’isoler les parties 220v (avec de la colle thermofusibles ou du ruban isolant).

Le code

L’ESP-01 ne dispose pas comme le D1 Mini Pro vu dans ce tutoriel d’une interface USB intégrée. Il vous faudra donc une interface USB/FTDI pour le programmer. Pour plus d’information, je vous invite à lire cet article.

A l’inverse du tutoriel précédent, ce code utilise la libraire TSL2561-Arduino-Library et non la « Unifed Sensor Library » afin de nous permettre de récupérer le Broadband et l’IR en plus des Lux.

Il faudra donc installer la libraire « TSL2561-Arduino-Library » depuis le Gestionnaire de bibliothèque. De plus on utilise ici « ArduinoThread » pour ordonner les mesures à intervalle régulier. Vous devrez également installer cette librairie.

Attention : si tout cela est nouveau pour vous, je vous recommande de suivre ce guide d’introduction à l’API Constellation pour Arduino/ESP8266.

Le code complet est :

#include <ESP8266WiFi.h>
const char* ssid     = "MON SSID";
const char* password = "lacléeWifi!!!!";

#include <Constellation.h>
Constellation<WiFiClient> constellation("IP ou DNS du serveur Constellation", 8088, "ESP-LightSensorSalon", "LightSensor", "123456789");

#include <Wire.h>
#include <TSL2561.h>
TSL2561 tsl(TSL2561_ADDR_FLOAT); 

#include <Thread.h>
Thread thrPushLux = Thread();

void pushLuxOnConstellation() {  
  uint32_t lum = tsl.getFullLuminosity();
  uint16_t ir, full;
  ir = lum >> 16;
  full = lum & 0xFFFF;
  uint32_t lux = tsl.calculateLux(full, ir);
  
  constellation.pushStateObject("Lux", stringFormat("{ 'Lux':%d, 'Broadband':%d, 'IR':%d }", lux, full, ir), "LightSensor.Lux", 300);
}

void setup(void) {
  Serial.begin(115200);  delay(10);

  if (tsl.begin()) {
    Serial.println("Found sensor");
  } else {
    Serial.println("No sensor?");
    while (1);
  }
  
  // You can change the gain on the fly, to adapt to brighter/dimmer light situations
  //tsl.setGain(TSL2561_GAIN_0X);         // set no gain (for bright situtations)
  tsl.setGain(TSL2561_GAIN_16X);      // set 16x gain (for dim situations)  
  // Changing the integration time gives you a longer time over which to sense light
  // longer timelines are slower, but are good in very low light situtations!
  //tsl.setTiming(TSL2561_INTEGRATIONTIME_13MS);  // shortest integration time (bright light)
  //tsl.setTiming(TSL2561_INTEGRATIONTIME_101MS);  // medium integration time (medium light)
  tsl.setTiming(TSL2561_INTEGRATIONTIME_402MS);  // longest integration time (dim light)

  // Set Wifi mode
  if (WiFi.getMode() != WIFI_STA) {
    WiFi.mode(WIFI_STA);
    delay(10);
  }
  
  // Connect to Wifi  
  Serial.print("Connecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);  
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("WiFi connected. IP: ");
  Serial.println(WiFi.localIP());
  Serial.println(constellation.getSentinelName());
  
  JsonObject& settings = constellation.getSettings();
  int interval = 10000; //ms
  if(settings.containsKey("Interval")) {
    interval = settings["Interval"].as<int>();
  }

  thrPushLux.onRun(pushLuxOnConstellation);
  thrPushLux.setInterval(interval);

  constellation.addStateObjectType("LightSensor.Lux", TypeDescriptor().setDescription("Lux data informations").addProperty("Broadband", "System.Int32").addProperty("IR", "System.Int32").addProperty("Lux", "System.Int32"));
  constellation.declarePackageDescriptor();
  
  constellation.writeInfo("ESP LightSensor '%s' is started (Push interval: %d sec)", constellation.getSentinelName(), interval);  
}

void loop(void) {
  if(thrPushLux.shouldRun()){
    thrPushLux.run();
  }
}

Pour démarrer vous devez dans Constellation déclarer une sentinelle associée à une clé d’accès et un package virtuel. Ici notre ESP8266 est représenté par la sentinelle nommée “ESP-LightSensorSalon” et le package virtuel se nomme “LightSensor”.

Ensuite il faut définir le nom de notre réseau Wifi (SSID) ainsi que sa clé d’accès puis nous configurerons le client Constellation en spécifiant l’identité de notre package virtuel, sa clé d’accès et l’adresse/port de notre serveur Constellation.

Dans la méthode « setup()« , on initialise le capteur TSL puis on se connecte au Wifi et enfin on déclare l’intervalle de temps entre chaque mesure, par défaut de 10 secondes qu’on peut modifier en ajoutant un setting « Interval » sur notre package virtuel.

On configure ensuite un « thread » qui exécutera à l’intervalle de temps spécifié la méthode « pushLuxOnConstellation« . Pour finir on déclare la description du StateObject par la méthode « constellation.addStateObjectType » et on affiche un log. Dans la loop(), on déclenche le thread.

La méthode « pushLuxOnConstellation » récupère les données du capteur et publie le StateObject « Lux » avec les trois propriétés :

constellation.pushStateObject("Lux", stringFormat("{ 'Lux':%d, 'Broadband':%d, 'IR':%d }", lux, full, ir), "LightSensor.Lux", 300);

Une fois le programme téléversé, votre prise publiera le StateObject à l’intervalle régulier la luminosité ambiante.

Exploiter le capteur

Comme vous le savez, une fois les données mesurées publiées dans un StateObject n’importe quel système connecté dans Constellation peut récupérer ou s’abonner en temps réel au StateObject.

On peut donc écrire des pages Web, des scripts, des packages .NET ou Python, Arduino, etc… qui exploiteront ces mesures en temps réel.

Je vous renvoie sur cette page ou cette autre page pour avoir quelques idées.

Pour ma part ce capteur installé dans le salon est affiché en temps réel sur un dashboard Web,  stocké dans ElasticSearch et Cacti et exploité dans un package .NET nommé « MyBrain » car cette information sur la luminosité ambiante sert dans beaucoup de scénario : gestion des éclairages ou des volets.

The post Créer un capteur de luminosité dans une prise 220v avec un ESP8266 appeared first on Constellation.

Pour être exact, le Raspberry Pi sera installé en intérieur, connecté au réseau filaire Ethernet et relié par un câble à un boitier étanche installé sur le toit qui contiendra une photorésistance et/ou un capteur TSL2561.

Nous allons utiliser un Raspberry B+ version 1 sur lequel nous installerons une sentinelle pour pouvoir déployer notre package depuis Visual Studio. Le package d’acquisition des données sera écrit en Python.

Prérequis

• Un serveur Constellation
• Un Raspberry Pi sur lequel nous installerons une sentinelle
• Une photorésistance avec un condensateur 1uF et/ou un capteur TSL2561
• Visual Studio avec le SDK Constellation

Mesurer la luminosité ambiante avec une photorésistance

Le montage

Tout d’abord, il nous faut un boitier étanche avec un couvercle transparent (pour mesurer la luminosité c’est mieux !) :

Sur une plaque epoxy, soudons la photorésistance avec un condensateur 1uF.

Une des deux pattes de la photorésistance sera reliée sur la pin « 3v3 » du Raspberry et la deuxième sera reliée à une entrée du Raspberry, disons la pin n°12 (soit la GPIO #18). Toujours sur cette 2ème patte, on soudera le pole « + » du condensateur. L’autre pole du condensateur, celle marquée « -« , devra être reliée à la masse, sur l’une des pins « GND » du Raspberry.

On a donc trois fils connectés entre le Raspberry et notre capteur : le 3V3 et la masse (Gnd) pour l’alimentation et un pour le signal (GPIO #18). L’idée est donc de « charger » le condensateur et de chronométrer le temps qu’il mets à se décharger.

Plus il y a de lumière et moins la résistance est forte, autrement dit le condensateur se déchargera très rapidement. A l’inverse, plus il fait sombre et plus la résistance sera forte. Autrement dit, moins il y a de lumière et moins vite se déchargera le condensateur.

On voit sur les photos ci-dessous, le fil Orange pour le 3V3, le fil Bleu pour la GPIO et le fil Blanc pour la masse (Gnd) :

Il fois les connexions réalisées, on peut refermer proprement notre boitier en vérifiant soigneusement son étanchéité avant de l’installer sur le toit.

Côté intérieur, on relie les 3 fils de notre boitier au Raspberry (3v3, Gnd et GPIO18), le câble Ethernet et l’alimentation MicroUSB.

Pour l’installation du système sur le Raspberry suivez ce guide puis installez-y une sentinelle. Votre Raspberry est prêt et connecté à Constellation, reste à développer notre package Python.

Programmation

Depuis Visual Studio, créons un nouveau projet de type « Constellation Python Package » que nous nommerons “LightSensor”.

Renommez le fichier « Demo.py » en « Light.py » et remplacez l’intégralité du contenu par le code suivant :

import Constellation
import RPi.GPIO as GPIO, time, os      

MAX_READING = 30000
LIGHT_SENSOR_GPIO = 18
MEASURE_INTERVAL = 10

def OnExit():
    GPIO.cleanup()

def RCtime (RCpin):
    reading = 0
    GPIO.setup(RCpin, GPIO.OUT)
    GPIO.output(RCpin, GPIO.LOW)
    time.sleep(0.1) 
    GPIO.setup(RCpin, GPIO.IN)
    # This takes about 1 millisecond per loop cycle
    while (GPIO.input(RCpin) == GPIO.LOW):
        if (reading > MAX_READING):
            break
        reading += 1
    return reading
 
def Start():
    global INTERVAL
    GPIO.setmode(GPIO.BCM)
    Constellation.OnExitCallback = OnExit
    lastSend = 0
    currentValue = 0
    count = 0
    Constellation.WriteInfo("LightSensor is ready !")
    while Constellation.IsRunning:
        currentValue = currentValue + RCtime(LIGHT_SENSOR_GPIO)
        count = count + 1
        ts = int(round(time.time()))
        if ts - lastSend >= int(Constellation.GetSetting("Interval")):
            avg = int(round(currentValue / count))
            Constellation.PushStateObject("Light", avg, "int")
            currentValue = 0
            count = 0
            lastSend = ts
        time.sleep(MEASURE_INTERVAL)

Constellation.Start(Start)

N’hésitez pas à relire le guide sur la création de package Python pour bien comprendre les bases d’un package Python.

Ici on démarre notre package par la méthode « Start » qui démarre une boucle pour appeler la méthode RCtime toutes les 10 secondes (variable MEASURE_INTERVAL).

La méthode RCtime charge le condensateur (mode output) puis passe l’I/O en « input » et incrémente la variable « reading » en continue tant que le condensateur n’est pas déchargé (input == « low »). Plus la valeur « reading » est élevée, plus le condensateur a mis du temps à se décharger et donc moins il y a de lumière. On a un garde-fou à « 30.000 » pour ne pas attendre indéfiniment dans le cas où il fait trop sombre.

Bien entendu on ne mesure pas une unité précise. Si vous déployez votre code sur un RPi V1 et V2 (plus puissant), vous n’aurez pas la même valeur pour les mêmes conditions.

Chaque mesure incrémente la variable « currentValue », puis dès qu’on atteint l’intervalle configuré dans les Settings Constellation, on fait la moyenne des mesures on publie un StateObject nommé « Light » de type « int ».

Dans le manifeste du package (PackageInfo.xml), n’oubliez pas de déclarer le setting « Interval » en lui spécifiant une valeur par défaut, ici de 10 seconde :

<Settings>
  <Setting name="Interval" isRequired="false" type="Int32" defaultValue="10" description="Interval to read sensors in second" />
</Settings>

De même vous pouvez également modifier les informations de compatibilité des plateformes pour exclure la plateforme Windows dans la mesure où le package exploite les GPIO du Raspberry.

<Platform id="Win32NT" isCompliant="false" />

Et voilà le package est prêt, vous pouvez depuis Visual Studio le publier dans votre Constellation :

… puis le déployer sur votre sentinelle Raspberry depuis la Console Constellation, en cliquant sur le bouton “Deploy new package” :

Dans l’assistant de déploiement vous pourrez alors personnaliser le setting “Interval” ou bien laisser la valeur par défaut que nous avons fixé à 10 (secondes) :

Sur la Console Log, le package va être téléchargé et déployé par votre sentinelle Raspberry avant de démarrer :

Et en vous rendant dans le StateObjects Explorer, vous verrez votre package “LightSensor” publier un StateObject “Light” avec un entier comme valeur :

Votre package Python est opérationnel, on peut dés à présent exploiter cette valeur dans une page Web, un script, un programme .NET ou Python, un Arduino, etc… comme nous le verrons dans la suite de cet article.

Mesurer des lux avec un capteur TSL2561

Pour obtenir une mesure plus fiable et surtout exploitant une échelle de mesure universelle, nous allons utiliser un capteur de luminosité TSL2561 capable de mesurer des Lux.

Le montage

Dans cette deuxième version, j’ai conservé la photorésistance et simplement ajouté le capteur TSL2561. Celui-ci est également alimenté en 3V3, j’ai donc réutilisé les deux fils (Orange et Blanc) de la photorésistance pour alimenter le capteur également.

Le TSL2561 utilise l’I²C, j’ai donc ajouté deux fils entre le boitier étanche et le Raspberry pour connecter le capteur en i²C (SDA et SCL).

Sur le Raspberry, le SDA est la GPIO#2 et le SCL la GPIO #3, c’est à dire juste en dessus de la pin 3v3.

La programmation

Le plus simple et le plus fiable pour récupérer les données du capteur TSL2561 depuis un Raspberry est d’utiliser un programme natif. Pour cela nous allons utiliser le code publié à cette adresse : http://dino.ciuffetti.info/2014/03/tsl2561-light-sensor-on-raspberry-pi-in-c/.

Il suffit récupérer les 3 fichiers C et de les compiler avec GCC pour générer le binaire. Pour vous simplifier la tache, vous pouvez directement récupérer le binaire GetTSL2561 ici.

Ajoutez ensuite un deuxième script nommé « Lux.py » dans le répertoire « Scripts » de votre projet et n’oubliez pas d’inclure votre script dans le package en définissant la Build Action à « Content » et en activant la copie du fichier dans le répertoire de sortie :

Copiez également le binaire GetTSL2561 dans le répertoire « Scripts » de votre package en l’incluant également dans le package (Build Action à Content et Copy if newer).

Le contenu du script « Lux.py » sera :

import Constellation
import os, re, subprocess, time, stat

# Const
EXECUTABLE_FILENAME = "GetTSL2561"

def DoMeasure():
    # Start process
    process = subprocess.Popen("./" + EXECUTABLE_FILENAME, stdout=subprocess.PIPE)
    # Reading  output
    for line in iter(process.stdout.readline, ''):
        # Parse line
        matchObj = re.match('RC: (\d*)\((.*)\), broadband: (\d*), ir: (\d*), lux: (\d*)', line)
        if matchObj:
            # Reading value
            returnCode = int(matchObj.group(1))
            broadband = int(matchObj.group(3))
            ir = int(matchObj.group(4))
            lux = int(matchObj.group(5))
            # Push StateObject
            if returnCode != 0:
                Constellation.WriteWarn("Unknow return code %s : %s" % (returnCode, line))
            else:
                Constellation.PushStateObject("Lux", { "Broadband": broadband, "IR" : ir, "Lux" : lux }, "LightSensor.Lux")
        else:
            Constellation.WriteError("Unable to parse the output: %s" % line)

def Start():    
    # Make the "GetTSL2561" file as executable
    st = os.stat(EXECUTABLE_FILENAME)
    os.chmod(EXECUTABLE_FILENAME, st.st_mode | stat.S_IEXEC)
    Constellation.WriteInfo("LuxSensor is ready !")
    while Constellation.IsRunning:  
        DoMeasure()
        time.sleep(int(Constellation.GetSetting("Interval")))

Constellation.Start(Start)

Comme pour le script « Light.py », on déclare la méthode « Start » comme méthode de démarrage. Celle-ci boucle tant que le package est démarré à l’intervalle défini par le setting « Interval » qu’on a déclaré à 10 secondes par défaut dans le manifeste.

A chaque itération, on invoque la méthode « DoMeasure » qui démarre le programme « GetTSL2561 » et on parse avec une regex le résultat de la sortie du programme (process.stdout) pour extraire le code de retour, le broadband (spectre visible), l’infrarouge et le nombre de lux courant mesuré par le capteur.

Si le code de retour est égal à 0 c’est que la mesure est correcte, on publie alors un StateObject nommé « Lux » contenant les trois propriétés mesurées : Broadband, IR et Lux.

Constellation.PushStateObject("Lux", { "Broadband": broadband, "IR" : ir, "Lux" : lux }, "LightSensor.Lux")

Attention avant de déployer cette nouvelle version il faut activer l’I²C sur le Raspberry. Pour cela lancer la commande « sudo raspi-config » puis dans le menu « Advanced Options » activez l’I²C et chargez le module par défaut au démarrage.

On peut maintenant publier cette nouvelle version depuis Visual Studio et lancer un « Reload » sur notre package pour déployer cette nouvelle version sur notre Rapsberry.

Désormais nous avons deux StateObjects publiés par ce package : « Light » via la photorésistance et « Lux » via le TSL2561 :

Notre nouveau StateObject « Lux » est un objet complexe contenant trois propriétés :

Exploitez les données

Notre package Python vit sa vie sur notre Raspberry et publie à intervalle régulier deux StateObjects sur base des mesures réalisées par la photorésistance et/ou le capteur de lux TSL2561.

On peut maintenant écrire des pages Web, des scripts, des packages .NET ou Python, Arduino, etc… qui exploiteront ces mesures en temps réel.

Un dashboard Web

Depuis une page Web, il suffit d’ajouter un StateObjectLink. Vous pouvez vous inspirer de ce tutoriel par exemple.

constellation.registerStateObjectLink("*", "LightSensor", "Lux", "*", function (so) {
  $scope.$apply(function () {
    console.log("Lux = ", so.Value.Lux);
  });
});

Par exemple sur le projet S-Panel avec quelques composants Bootstrap :

Un programme .NET

Vous pouvez là aussi vous inspirer de ce tutoriel. En clair, il suffit dans votre code C# d’ajouter des StateObjectLinks avec l’API.NET :

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

Ainsi la propriété .NET nommée « Lux » ci-dessus sera liée en temps réel au StateObject « Lux » du package « LigthSensor ».

Vous pouvez ajouter des événements dès que la valeur change :

this.Lux.ValueChanged += (s, e) =>
{
    PackageHost.WriteInfo($"Nouvelle mesure à {this.Lux.Value.LastUpdate} = {this.Lux.DynamicValue.Lux} lux");
};

Vous pouvez ainsi faire ce que bon vous semble avec cette information. Par exemple allumer automatiquement les lumières si la luminosité est trop faible, fermer les volets, enregistrer la valeur des Lux dans un fichier Excel ou une base de données, etc.. etc..

Historisation avec ElasticSearch / Kibana

En utilisant le package Graylog du catalogue de package, on peut historiser les mesures de notre capteur dans une base ElasticSearch.

Dans la configuration du package Graylog, on aura quelque chose comme :

<graylogConfiguration xmlns="urn:GraylogConnector" sendPackageLogs="false" sendPackageStates="true" sendSentinelUpdates="true">
    <subscriptions>
        <subscription package="LightSensor" name="Lux" />
        <!-- ..... -->
    </subscriptions>
    <outputs>
        <gelfOutput name="Graylog server UDP" host="graylog.ajsinfo.loc" port="12201" protocol="Udp" />
    </outputs>
</graylogConfiguration>

La documentation du package Graylog est disponible ici. En résumé on crée ici un abonnement pour la StateObject « Lux » du package « LightSensor » et dans les « outputs » on a déclaré notre serveur Graylog.

De ce fait dès que le StateObject « Lux » est mis à jour par notre package Python, le package Graylog enregistre la nouvelle version du StateObject sur le serveur Graylog qui lui-même utilise ElasticSearch comme base de stockage.

Ainsi on pourra utiliser un outil comme Kibana pour visualiser l’évolution de notre StateObject :

Un article complet sur le sujet a été publié ici.

Stats avec Cacti

On peut également écrire un script pour récupérer notre StateObject « Lux » depuis l’interface REST qu’on ajoutera en tant que « Data Input Methods » dans Cacti pour pouvoir créer des graphiques facilement :

The post Un capteur de luminosité extérieur piloté par un Raspberry avec un package Python appeared first on Constellation.