Dans ce tutoriel, nous allons créer un boitier qui est relié à un ou plusieurs ordinateurs de la maison grâce à un ESP8266 connecté à constellation. Des LEDs permettent à l’utilisateur de suivre le résultat des commandes en temps réel. Le boitier permet de commander à distance le lecteur de vidéo VLC media player à travers différentes fonctionnalités. Il gère :

• Le volume
• La marche avant / marche arrière au cours d’un visionnage
• La mise en lecture / pause d’une vidéo
• La fermeture de VLC

Prérequis

• Un ESP8266, nous utilisons un D1-mini
• 6 boutons poussoirs tactiles blancs
• 2 LEDs RGB
• Une plaque de plexiglas noire
• Une imprimante laser
• Un serveur constellation
• Le package « Windows Control » déployé sur une ou plusieurs sentinelles

Etape 1 : Réaliser le montage des boutons et LEDs

Dans un premier temps, nous allons réaliser le montage électronique des composants. Tout d’abord il est nécessaire de brancher l’ESP8266 à la breadboard et de l’alimenter en le connectant en mini-USB à une source d’alimentation. Il faut ensuite brancher la masse de l’ESP à la colonne de masse de la breadboard.

Pour les besoins de l’explication du montage, tous les autres composants seront connectés à la breadboard, cependant il est tout à fait possible de les connecter une fois insérés dans le boitier (voir Etape 2). Le schéma global est présenté ci-après.

Ici nous avons choisi 2 LEDs RGB afin d’améliorer l’effet visuel pour obtenir une LED de couleur jaune. La première LED verte pourra être connectée directement au pin D8 de l’ESP. Quant à la seconde LED RGB, il suffit de connecter les pattes correspondant aux LEDs rouge et verte à la même ligne, puis de lier cette ligne au pin D7 de l’ESP.

Les boutons poussoirs sont à connecter avec les broches 1 et 3 d’un côté et les broches 2 et 4 de l’autre. Le branchement est classique, à savoir les pin D1 à D6 connectés directement sur la patte 1 de chaque bouton, puis retour à la masse sur la patte 3 des boutons. Lorsque l’on appuie sur le bouton, le pin correspondant passera donc en état bas (LOW) et est en état haut (HIGH) tant que l’on n’appuie pas.

Une fois le câblage terminé, nous allons passer à la réalisation du boitier qui contiendra à l’intérieur l’ESP et la breadboard.

Etape 2 : Réaliser le boitier

Dans un second temps, il nous faut un boitier que nous pourrons ouvrir pour mettre notre ESP. Le design de la face de devant doit aussi correspondre au nombre de boutons et LED que l’on souhaite mettre en place.

Afin de résoudre cette problématique, nous avons décidé d’imprimer le boitier grâce à une imprimante laser. Nous avons utilisé une plaque de plexiglas noir d’une épaisseur de 3mm.

Tout d’abord, nous avons créé le fond de la boite sans le couvercle. Nous avons utilisé le site : http://carrefour-numerique.cite-sciences.fr/fablab/wiki/doku.php?id=projets:generateur_de_boites qui permet de générer automatique le fichier .svg qui sera reconnu et utilisé pour l’impression laser. Il suffit d’entrer les dimensions voulues.

Ensuite nous avons utilisé SolidWorks afin de créer notre face avant personnalisée. Nous avons choisi percer 2 trous pour les LEDs et 6 pour les boutons carrés. Après la réalisation de la pièce, plusieurs étapes sont alors nécessaires pour exporter le fichier SolidWorks en fichier .svg.

• Sélectionner la vue correspondant à la pièce à réaliser
• Enregistrer le fichier SolidWorks au format .DXF.
• Sélectionner la vue à exporter. Ici, on sélectionne la vue en cours.

• Installer Inkscape, ce logiciel permettra de créer le fichier pour l’imprimante laser.
• Importer le fichier dans Inkscape. Il faut désactiver mise à l’échelle automatique.
• Sauvegarder le fichier qui sera utilisé pour l’impression laser.

Enfin, nous avons assemblé toutes les pièces du boitier :

Etape 3 : Programmation

Dans un premier temps, il faut vous assurer que votre ESP8266 soit connecté à votre constellation, si vous ne savez pas comment vous y prendre, je vous invite donc à suivre le tutoriel réalisé par Sébastien Warin : https://developer.myconstellation.io/getting-started/connecter-un-arduino-ou-un-esp8266-constellation/ .

Pour commencer, il faut déclarer le matériel dans la méthode setup de notre ESP8266, conformément à l’étape 1, nous avons choisi les pin 1 à 6 en mode PULLUP pour les boutons et les pins 7 & 8 pour les LEDs :

pinMode(D1,INPUT_PULLUP);
  pinMode(D2,INPUT_PULLUP);
  pinMode(D3,INPUT_PULLUP);
  pinMode(D4,INPUT_PULLUP);
  pinMode(D5,INPUT_PULLUP);
  pinMode(D6,INPUT_PULLUP);
  pinMode(D7,OUTPUT);
  pinMode(D8,OUTPUT);
  digitalWrite(D7,LOW);
  digitalWrite(D8,LOW);

Nous avons associé à chaque bouton un messageCallback avec les paramètres permettant d’effectuer l’action voulu. Pour faire cela, nous avons réalisé une fonction « checkButtonState » qui permet de gérer les évènements d’appuie sur les boutons et d’appeler le messageCallback correspondant au bouton. Juste avant l’appel du messageCallback, la led cablée au pin D7 est allumée pour une période de 2 secondes afin de montrer à l’utilisateur que l’ESP8266 a bien réalisé l’action. Cela permettra en cas de disfonctionnement, que l’utilisateur puisse savoir si c’est le hardware ou la transmission Wifi/Constellation qui est défectueux.

Le tableau ci-dessous récapitule les actions, messageCallback et pins qui sont associés ensemble :

Ci-dessous le code de la fonction checkButtonState :

void checkButtonState(){
  
  static int lastButtonStateD1 = HIGH;
  static int lastButtonStateD2 = HIGH;
  static int lastButtonStateD3 = HIGH;
  static int lastButtonStateD4 = HIGH;
  static int lastButtonStateD5 = HIGH;
  static int lastButtonStateD6 = HIGH;
  static long led1TimeLitUP = 0;
  // If the led is lit up for 2 secondes, we shut off the led
  if(millis() - led1TimeLitUP >2000){
      digitalWrite(D7, LOW);
    }
  // We retrieve the pin value
  int reading = digitalRead(D1);
// If pin value has changed
  if (reading != lastButtonStateD1){
   // And if pin value is high which mean button is pushed, then we make the associated action
    if (reading == HIGH){
      // We lit up the led in order to show to the user that the messageCallback is sending
       digitalWrite(D7,HIGH);
       // "led1TimeLitUp" take the value of the moment when it has been litted up
       led1TimeLitUP = millis();
       // we use the messageCallback to do the wanted action
       constellation.sendMessage(Package, "WindowsControl", "VolumeUp","{}");
     
      }
      lastButtonStateD1 = reading ;
     
      return;
  }
  reading = digitalRead(D2);
  if (reading != lastButtonStateD2){
     if (reading == HIGH){
        digitalWrite(D7,HIGH); 
        led1TimeLitUP = millis();
        constellation.sendMessage(Package, "WindowsControl", "VolumeDown", "{}"); 
        
      }
      lastButtonStateD2 = reading;
      return;
    }
  reading = digitalRead(D3);
  if (reading != lastButtonStateD3){
     if (reading == HIGH){
        digitalWrite(D7,HIGH); 
        led1TimeLitUP = millis();
        constellation.sendMessage(Package, "WindowsControl", "SendKey", "SpaceBar");
       
      }
      lastButtonStateD3 = reading;
      return;
    }
    
  reading = digitalRead(D4);
  if (reading != lastButtonStateD4){
     if (reading == HIGH){
        digitalWrite(D7,HIGH); 
        led1TimeLitUP = millis();
        constellation.sendMessage(Package, "WindowsControl", "SendCombinationOfKey", "['ALT', 'Left']");
        
      }
      lastButtonStateD4 = reading;
      return;
    }
   reading = digitalRead(D5);
    if (reading != lastButtonStateD5){
     if (reading == HIGH){
        digitalWrite(D7,HIGH); 
        led1TimeLitUP = millis();
        constellation.sendMessage(Package, "WindowsControl", "SendCombinationOfKey", "['ALT', 'Right']");
      
      }
      lastButtonStateD5 = reading;
      return;
    }
    reading = digitalRead(D6);
    if (reading != lastButtonStateD6){
     if (reading == HIGH){
        digitalWrite(D7,HIGH); 
        led1TimeLitUP = millis();
        constellation.sendMessage(Package, "WindowsControl", "SendCombinationOfKey", "['CTRL', 'Q']");
        
      }
      lastButtonStateD6 = reading;
      return;
    }  
  }

Et voilà notre boitier de contrôle est opérationnel. Il ne reste plus qu’à l’alimenter et vous avons à notre disposition des boutons physiques pour piloter notre Windows facilement.

The post Créer un boitier connecté « Mix box » permettant de contrôler votre ordinateur 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.

Pour cela nous allons utiliser un encodeur rotatif aussi nommé potentiomètre angulaire comme le KY-040 (comptez entre 50 cts et 2 euros pièce) avec un ESP8266 connecté en Wifi à votre Constellation.

Prérequis

Pour réaliser ce tutoriel, il nous faut :

• Un ESP8266, ici nous utilisons un D1 Mini Pro
• Un encodeur rotatif KY-040
• Un serveur Constellation
• Le package WindowsControl déployé sur au moins une sentinelle Windows

Etape 1 : créer un encodeur rotatif connecté

Le KY-040 a 5 pins : deux pour l’alimentation (5V et Gnd), deux pour l’encodeur rotatif (CLK et DT) et un dernier pour le bouton (lorsque l’on pousse sur le potentiomètre).

Nous allons donc tout simplement connecter les pin 5V et Gnd sur le port 5V et Gnd de notre D1 Mini Pro. Les pins CLK et DT respectivement sur les ports D1 et D2 et le switch (pin SW) sur le port D3.

Vous pouvez optionnellement habiller le potentiomètre avec un bouchon, ci-dessous récupéré sur une veille chaine Hifi :

Votre encodeur est prêt, il ne reste plus qu’à le programmer.

Etape 2 : programmer l’ESP8266

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 “ESP8266” et le package virtuel se nomme “RotaryController”.

Dans l’Arduino IDE, nous créons un nouveau projet à partir du Starter Kit Constellation pour ESP8266 dans lequel nous allons 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 :

// ESP8266 Wifi
#include <ESP8266WiFi.h>
char ssid[] = "MON SSID";
char password[] = "macléWifi!!!!";

// Constellation client
Constellation<WiFiClient> constellation("X.X.X.X", 8088, "ESP8266", "RotaryController", "xxxxxxxxxxxxxxxxx");

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

Maintenant que la coquille de notre package virtuel sur ESP8266 est prête, ajoutons une librairie pour interpréter les signaux du KY-040 (inputs CLK et DT) pour connaitre et mesurer le mouvement du potentiomètre.

Dans le gestionnaire de bibliothèque (menu Croquis > Inclure une bibliothèque), installez la librairie “Encoder” de Paul Stoffregen et ajoutez-la dans votre code avant de déclarer une variable de type “Encoder” que nous nommerons “encoder”.

Pour rappel nous avons connecté le KY-040 sur les ports D1 (CLK) et D2 (DT) et le bouton sur D3 (SW) :

#include <Encoder.h>

Encoder encoder(D1, D2);
int pinSW = D3;

Le bouton poussoir du potentiomètre est un simple bouton poussoir connecté en « pull-up » (à la masse). Il n’est donc pas traité par la librairie « Encoder » et sera interprété avec un simple « digitalRead« .

Toujours dans l’entête de votre code, configurons les valeurs par défaut suivantes :

// Default values
static String target = "WindowsControl";
static String mcbUp = "VolumeUp";
static String mcbDown = "VolumeDown";
static String mcbPush = "Mute";

Ici on configure où on va envoyer le message, par défaut au scope du package « WindowsControl ».

A ce package « WindowsControl » on enverra :

• Un message « VolumeUp » si le potentiomètre « monte »
• Un message « VolumeDown » si le potentiomètre « descend »
• Un message « Mute » si on pousse le potentiomètre « monte »

C’est à dire que par défaut, notre potentiomètre connecté contrôlera le volume des PC Windows où le package WindowsControl est déployé. On pourra par la suite personnaliser ces actions dans les settings comme nous le verrons ci-dessous.

Entrons maintenant dans le code de la méthode « setup()« . Ajoutons la ligne suivante pour initialiser l’entrée D3 où est connecté le bouton poussoir :

// Init I/O
pinMode(pinSW, INPUT_PULLUP);

Enregistrons ensuite un MessageCallback « ReloadSettings » pour permettre de recharger la configuration « à la volée » sans devoir redémarrer notre EPS. Ce MessageCallback se charge d’invoquer la fonction « loadSettings()« .

De plus, à la fin de notre méthode « setup() » invoquons cette méthode « loadSettings() » pour charger la configuration au démarrage.

// ReloadSettings MessageCallback
constellation.registerMessageCallback("ReloadSettings", MessageCallbackDescriptor().setDescription("Reload the settings"),
  [](JsonObject& json) {
    loadSettings();
    constellation.writeInfo("Settings reloaded");
 });
constellation.declarePackageDescriptor();

// Load settings on start
loadSettings();

Cette méthode « loadSettings() » récupère les settings sur le serveur Constellation et écrase la valeur par défaut si le setting est défini sur le serveur.

void loadSettings() {
  JsonObject& settings = constellation.getSettings();
  if(settings.containsKey("Target")) {
    target = String(settings["Target"].asString());
  }
  if(settings.containsKey("OnUp")) {
    mcbUp = String(settings["OnUp"].asString());
  }
  if(settings.containsKey("OnDown")) {
    mcbDown = String(settings["OnDown"].asString());
  }
  if(settings.containsKey("OnPush")) {
    mcbPush = String(settings["OnPush"].asString());
  }
}

De ce fait par défaut, notre potentiomètre connecté invoque le MessageCallback « VolumeUp » sur le package « WindowsControl » lorsque l’on tourne à droite, « VolumeDown » à gauche ou « Mute » lorsqu’on appuie dessus. Il suffira d’ajouter/modifier les settings de notre package virtuel depuis la Console Constellation pour modifier ces actions.

Il ne reste plus qu’à définir le code de la boucle principale, la fonction « loop()« .

Celle-ci lit la valeur de l’encodeur rotatif et envoi les messages dans Constellation en cas de montée ou de descente. La boucle lit également la valeur de l’entrée D3 pour envoyer le message en cas d’appui sur le potentiomètre.

void loop(void) {
  constellation.loop();

  static long lastValue = -1;
  long value = encoder.read();
  if (value != lastValue && abs(value - lastValue) >= 4) {
    if(lastValue > value) {
      Serial.println("Up");
      constellation.sendMessage(Package, target.c_str(), mcbUp.c_str(), "{}");
    }
    else {
      Serial.println("Down");
      constellation.sendMessage(Package, target.c_str(), mcbDown.c_str(), "{}");
    }    
    lastValue = value;
  }
  
  static int lastButtonState = LOW; 
  int buttonState = digitalRead(pinSW);
  if (buttonState != lastButtonState && buttonState == LOW) {
     Serial.println("Push");
     constellation.sendMessage(Package, target.c_str(), mcbPush.c_str(), "{}");
  }
  lastButtonState = buttonState;  
}

Et voilà votre potentiomètre connecté est opérationnel !

Démos

Piloter le volume de vos PC

Une fois le programme téléversé sur votre ESP8266, vous pouvez tourner le potentiomètre à gauche ou à droite pour diminuer ou augmenter le volume. Si vous appuyez sur le bouton, vous alternez entre les modes « mute/un-mute ».

Par contre si vous avez déployé le package WindowsControl sur plusieurs de vos sentinelles, vous contrôlerez simultanément le volume sur TOUTES vos sentinelles comme le montre l’animation ci-dessus.

Souvenez-vous du concept d’instance, ici notre ESP8266 envoie un message au scope « WindowsControl », c’est donc TOUTES les instances du package « WindowsControl » qui recevrons le message.

Piloter le volume d’un PC en particulier

Pour contrôler le volume d’un PC en particulier, il faut envoyer les messages au scope d’une instance du « WindowsControl » en particulier.

Pour cela nous devez spécifier l’instance selon la nomenclature suivante : « SENTINEL/Package ».

Par exemple, le nom de la sentinelle sur laquelle est déployée le package WindowsControl est « PC-SEB_UI ». Il faudra donc que j’envoie les messages au package « PC-SEB_UI/WindowsControl » pour contrôler le volume de mon ordinateur « PC-SEB » et non de tous.

Comme nous avons créé un système personnalisable en se servant des settings Constellation, il me suffit, depuis la Console Constellation, d’ajouter le setting que nous avons nommé « Target » pour définir le nom du scope où envoyer les messages :

Et voilà, désormais je ne pilote que le volume de cette machine en particulier et non de toutes mes machines.

Piloter la luminosité d’un PC

Si on observe les MessageCallbacks du package WindowsControl, on constate qu’il expose d’autre MCs dont « BrightnessUp » et « BrightnessDown » pour augmenter ou diminuer la luminosité.

Avec notre code se base sur les settings, nous pouvons modifier le nom des MC à invoquer en ajoutant/modifiant les settings du package.

Ajoutons donc deux settings nommés « OnUp » et « OnDown » respectivement définis avec les valeurs « BrightnessUp » et « BrightnessDown ». Invoquons ensuite le MC « ReloadSettings » sur notre package virtuel ou bien appuyez sur le bouton « Reset » de votre ESP8266 pour le redémarrer et donc recharger les settings :

Désormais notre potentiomètre connecté pilotera la luminosité :

Pour aller plus loin …

Comme vous l’avez vu, notre potentiomètre est entièrement personnalisable car le nom des MC à invoquer en cas de montée, descente ou d’appui sur le potentiomètre est personnalisable dans les settings.

Ici on pilote le volume ou la luminosité d’un Windows grâce au package WindowsControl, mais on pourrait également piloter tout type de chose : l’intensité d’une lampe, le thermostat, le toit ouvrant d’une voiture ou bien des valeurs de vos programmes ou pages Web, par exemple le slider d’une page HTML !

Libre à votre imagination

The post Un potentiomètre connecté pour contrôler le volume de votre PC, la luminosité de l’écran et bien plus encore appeared first on Constellation.

Le code source de ce package est en ligne sur : https://github.com/myconstellation/constellation-packages/tree/master/WindowsControl

Installation

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

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="WindowsControl" />

Détails du package

Les Settings

Ce package ne comporte aucun setting.

Les StateObjects

Vous retrouverez le StateObject suivant :

Les MessageCallbacks

Le package expose 6 MessageCallbacks :

Quelques exemples

• Synchroniser la lampe du bureau avec l’état de la session Windows
• Eteindre toutes ses machines Windows avec un script Powershell
• Mise en veille automatique d’une machine en cas d’absence de mouvement

The post WindowsControl : contrôlez vos ordinateurs Windows depuis Constellation appeared first on Constellation.

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

Installation

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

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

Pour finir, sur la page de Settings, vous devez obligatoirement définir le setting “PerfCounters”. Il s’agit d’un setting de type “ConfigurationSection” c’est à dire que la configuration de ce setting est décrite en XML.

<perfCounterSection xmlns="urn:PerfCounter">
  <perfCounters>     
    <perfCounter id="<< StateObject Name >>" categoryName="<<  Performance Counter Category Name >>" counterName="<< Performance Counter Counter Name >>"  instanceName="<< Optionnal Performance Counter Instance Name >>" />
  </perfCounters>
</perfCounterSection>

Vous devez spécifier une liste de <perfCounter> dont les attributs sont :

• id (obligatoire) : l’identifiant unique de ce compteur performance qui sera utilisé comme nom pour le StateObject
• categoryName (obligatoire) : la catégorie du compteur de performance
• counterName (obligatoire) : le nom du compteur de performance
• instanceName (optionnel) : le nom de l’instance du compteur de performance si nécessaire
• machineName (optionnel) : le nom de la machine sur laquelle récupérer le compteur de performance (si vide, c’est la machine il s’agit local)

Par exemple pour récupérer la mémoire RAM disponible (catégorie “Memory”, nom “Available MBytes”, aucune instance) :

<perfCounter id="MemoryAvailableMBytes" categoryName="Memory" counterName="Available MBytes"  />

Pour la consommation globale du CPU (catégorie “Processor”, nom “% Processor Time”, instance “_Total”) :

<perfCounter id="ProcessorTime" categoryName="Processor" counterName="% Processor Time" instanceName="_Total" />

Chaque produit (Constellation Server y compris) peuvent publier des compteurs de performances (ASP.NET, IIS, SQL Server, Windows, etc..). Vous pouvez donc facilement les injecter dans Constellation.

Par exemple, ci-dessous une configuration du package injectant dans Constellation les compteurs de performance relatif au processeur, mémoire RAM, interfaces réseau, disque physique C:, ASP.NET, la CLR .net, le service IIS et SQL Server :

<perfCounterSection xmlns="urn:PerfCounter">
   <perfCounters>     

     <!-- Processor -->
     <perfCounter id="ProcessorTime" categoryName="Processor" counterName="% Processor Time" instanceName="_Total" />
     <perfCounter id="ProcessorQueueLength" categoryName="System" counterName="Processor Queue Length" />

     <!-- Disk -->
     <perfCounter id="Disk0_IdleTime" categoryName="PhysicalDisk" counterName="% Idle Time" instanceName="0 C:" />
     <perfCounter id="Disk0_SecPerRead" categoryName="PhysicalDisk" counterName="Avg. Disk sec/read"   instanceName="0 C:"/>
     <perfCounter id="Disk0_SecPerWrite" categoryName="PhysicalDisk" counterName="Avg. Disk sec/write"  instanceName="0 C:" />
     <perfCounter id="Disk0_QueueLength" categoryName="PhysicalDisk" counterName="Current Disk Queue Length"  instanceName="0 C:" />

     <!-- Memory -->
     <perfCounter id="MemoryAvailableMBytes" categoryName="Memory" counterName="Available MBytes"  />
     <perfCounter id="MemoryPagesPerSec" categoryName="Memory" counterName="Pages/sec"  />
     <perfCounter id="MemoryCacheBytes" categoryName="Memory" counterName="Cache Bytes"  />

     <!-- Network Interface -->
     <perfCounter id="NetworkIntefaceBytesPerSec" categoryName="Network Interface" counterName="Bytes Total/sec" instanceName="Broadcom NetXtreme 57xx Gigabit Controller"  />
     <perfCounter id="NetworkIntefaceOutputQueueLength" categoryName="Network Interface" counterName="Output Queue Length" instanceName="Broadcom NetXtreme 57xx Gigabit Controller" />

     <!-- Paging File -->
     <perfCounter id="PagingFileUsage" categoryName="Paging File" counterName="% Usage" instanceName="_Total"  />

     <!-- .NET CLR -->
     <perfCounter id="DotNetExceptionThrownPerSec" categoryName=".NET CLR Exceptions" counterName="# of Exceps Thrown / Sec" instanceName="_Global_" />
     <perfCounter id="DotNetTotalCommittedBytes" categoryName=".NET CLR Memory" counterName="# Total Committed Bytes" instanceName="_Global_" />

     <!-- ASP.NET -->
     <perfCounter id="AspNetRequestPerSec" categoryName="ASP.NET Applications" counterName="Requests/Sec" instanceName="__Total__" />
     <perfCounter id="AspNetApplicationRestart" categoryName="ASP.NET" counterName="Application Restarts" />
     <perfCounter id="AspNetRequestWaitTime" categoryName="ASP.NET" counterName="Request Wait Time" />
     <perfCounter id="AspNetRequestQueued" categoryName="ASP.NET" counterName="Requests Queued" />

     <!-- IIS -->
     <perfCounter id="IISGetRequestPerSec" categoryName="Web Service" counterName="Get Requests/sec" instanceName="_Total"  />
     <perfCounter id="IISPostRequestPerSec" categoryName="Web Service" counterName="Post Requests/sec" instanceName="_Total"  />
     <perfCounter id="IISCurrentConnections" categoryName="Web Service" counterName="Current Connections" instanceName="_Total"  />

     <!-- SQL Server -->
     <perfCounter id="SqlBufferCacheHitRatio" categoryName="MSSQL$SQL2012:Buffer Manager" counterName="Buffer cache hit ratio" />
     <perfCounter id="SqlPageLifeExpectancy" categoryName="MSSQL$SQL2012:Buffer Manager" counterName="Page life expectancy" />
     <perfCounter id="SqlBatchRequestsPerSec" categoryName="MSSQL$SQL2012:SQL Statistics" counterName="Batch Requests/Sec" />
     <perfCounter id="SqlSQLCompilationsPerSec" categoryName="MSSQL$SQL2012:SQL Statistics" counterName="SQL Compilations/Sec" />
     <perfCounter id="SqlSQLReCompilationsPerSec" categoryName="MSSQL$SQL2012:SQL Statistics" counterName="SQL Re-Compilations/Sec" />
     <perfCounter id="SqlUserConnections" categoryName="MSSQL$SQL2012:General Statistics" counterName="User Connections" />
     <perfCounter id="SqlLockWaitsPerSec" categoryName="MSSQL$SQL2012:Locks" counterName="Lock Waits/sec" instanceName="_Total" />
     <perfCounter id="SqlPageSplitsPerSec" categoryName="MSSQL$SQL2012:Access Methods" counterName="Page Splits/sec" />
     <perfCounter id="SqlProcessesBlocked" categoryName="MSSQL$SQL2012:General Statistics" counterName="Processes Blocked" />
     <perfCounter id="SqlCheckpointPagesPerSec" categoryName="MSSQL$SQL2012:Buffer Manager" counterName="Checkpoint Pages/sec" />

   </perfCounters>
 </perfCounterSection>

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

<package name="perfcounter">
  <settings>
    <setting key="PerfCounters">
        <content>
          <perfCounterSection xmlns="urn:PerfCounter">
            <perfCounters>     
              <perfCounter id="<< StateObject Name >>" categoryName="<<  Performance Counter Category Name >>" counterName="<< Performance Counter Counter Name >>"  instanceName="<< Optionnal Performance Counter Instance Name >>" />
            </perfCounters>
          </perfCounterSection>
        </content>
      </setting>
  </settings>
</package>

Détails du package

Les Settings

Les StateObjects

Vous retrouverez autant de StateObject que de compteur de performance enregistrés dans la configuration de votre package.

Les MessageCallbacks

Ce package n’expose aucun MessageCallback.

Quelques exemples

• Afficher les valeurs des PerfCounters de différents serveurs Windows sur une page Web
• Piloter une bande de LED en fonction du nombre de requête HTTP sur un serveur IIS avec un Arduino/ESP

The post PerfCounter : intégrez les compteurs de performance Windows dans Constellation appeared first on Constellation.

Découvrons dans cet article comment créer et déployer votre premier package Constellation en Python.

Prérequis

Tout d’abord, que vous soyez sur Windows ou Linux, il vous faudra un interpréteur Python 2 ou Python 3 et une ou deux libraires indispensables pour Constellation.

Notez que ces prérequis sont automatiquement installés sur Linux avec le Web Platform Installer.

Installer Python sur Windows

Téléchargez Python pour Windows (en version 2.x ou 3.x) puis lancez l’installation en choisissant une installation pour tous les utilisateurs :

Sélectionnez le composant “PIP” ( le gestionnaire de package Python) et ajoutez “Python.exe” dans les “Paths” Windows :

Une fois l’installation terminée, lancez une invite de commande (cmd.exe) et assurez-vous que la commande “python” fonctionne :

Toujours dans une invite de commande Windows, installez via PIP les librairies “pyzmq” (et “enum34” si vous êtes en Python 2.x) grâce aux commandes suivantes :

pip install pyzmq
pip install enum34

Si vous êtes sur Python 3.x, vous n’avez pas besoin du module “enum34”, seulement “pyzmq”.

Et voilà, votre environnement Windows est prêt !

Installer Python sur Linux

Sur un système Debian ou similaire (Raspbian, Ubuntu, etc …), vous n’avez qu’à installer (et enregistrer dans votre Constellation) une sentinelle Constellation.

Le Web Platform Installer vous proposera d’installer tous les prérequis nécessaires à savoir Python et les librairies “pyZmq” et “enum34” (si Python 2.x) via PIP.

Autrement, pour installer manuellement ces prérequis, vous pouvez utiliser les mêmes commandes que sur Windows :

sudo easy_install pip
sudo pip install pyzmq
sudo pip install enum34

Encore une fois, la libraire “enum34” est seulement requise sur Python 2.x.

Enfin si vous utilisez un Raspberry Pi, vous pouvez également consulter cet article en particulier.

Et voilà, votre environnement Linux est prêt !

Développer un package Python en ligne de commande

Vous pouvez soit utiliser le SDK Constellation basé sur Visual Studio pour créer, tester et déployer des packages Constellation (.NET ou Python) ou bien, utiliser l’outil en ligne de commande nommé « Constellation Package Tools CLI ».

Le développement sous Visual Studio est abordé ci-dessous. Pour l’outil en ligne de commande, rendez-vous sur la page : Créer, tester et déployer des packages Python en ligne de commande

Développer un package Python avec Visual Studio

Après avoir installé les prérequis et le SDK Constellation, lancez Visual Studio et créez un nouveau package Constellation de type “Python” :

Une fois créé le projet Visual Studio a la structure suivante :

Vous retrouverez une structure classique pour un package Constellation :

• App.config : le fichier de configuration local pour définir les valeurs locales de vos settings (lire ici) ainsi que les scripts Python à démarrer
• PackageInfo.xml : le manifeste de votre package
• packages.config : le fichier des packages Nuget de votre projet (réservé à Nuget)
• Program.cs : le point d’entrée (C#) de votre package qui se chargera de lancer le “Python Proxy” (le pont entre vos scripts Python et Constellation)
• Le répertoire “Scripts” (qui contient vos scripts Python)
  • Constellation.py : le proxy Python Constellation (la librairie Python) : ne pas modifier !
  • Demo.py : un script Python d’exemple

Configurer les scripts à démarrer

Vous pouvez ajouter autant de scripts Python dans le dossier “Scripts” comme vous le souhaitez. Pour cela, cliquez-droit sur ce répertoire et sélectionnez « Ajouter un nouvel élément ».

Dans la catégorie « Constellation » sélectionnez « Constellation Python Script » :

Chaque script sera démarré dans un processus dédié et connecté à Constellation.

Attention : si vous rajoutez des scripts Python dans ce dossier, il faut obligatoirement les inclure dans le package en sélectionnant “Copy if newer” pour la propriété “Copy to Output directory”. Cette propriété est automatiquement définie à cette valeur si vous avez créé votre fichier Python en sélectionnant l’élément « Constellation Python Script » comme expliqué ci-dessus.

Dans le fichier « App.config » vous devez déclarer les fichiers Python à démarrer. Les scripts Python créé en sélectionnant l’élément « Constellation Python Script » sont automatiquement ajoutés dans ce fichier lors de la création. Si vous renommez ou supprimer vos scripts, n’oubliez pas de mettre à jour ce fichier.

<pythonProxy xmlns="urn:Constellation.PythonProxy">
  <scripts>
    <script filename="Scripts\Demo.py" />
    <script filename="Scripts\LightSensor.py" />
    <script filename="Scripts\Camera.py" />
  </scripts>
</pythonProxy>

Le script “Demo.py” est créé à titre d’exemple. Vous pouvez le supprimer, renommer ou modifier à votre convenance.

Grâce à Visual Studio et au SDK Constellation, vous bénéficiez d’un environnement de développement agréable pour créer vos packages Python avec la coloration syntaxique et l’IntelliSense :

Les bases

Chaque script Python doit impérativement importer la librairie Constellation et démarrer la “connexion” avec le proxy Python en invoquant la méthode “Start” :

import Constellation
# Votre code !
Constellation.Start()

Vous avez trois façon de démarrer cette connexion :

1 – La plus simple est d’invoquer la méthode “Start” :

Constellation.Start()

La méthode “Start” démarre la connexion et maintient le script en “vie” grâce à une boucle qui tourne tant que le package Constellation est lancé.

Autrement dit le code après la méthode “Start” ne sera jamais appelé !

2 – Invoquer la méthode “Start” en passant une fonction de démarrage :

Vous pouvez passer le nom d’une fonction en paramètre de la méthode “Start” qui sera invoquée dès que le script Python est connecté à Constellation.

Cela vous permet de définir du code au démarrage du package :

def OnStart():
    # Mon code de démarrage ici
    pass

Constellation.Start(OnStart);

3 – Troisième méthode : invoquer la méthode “StartAsync” (non bloquante)

Mais attention vous devrez vous même créer une boucle pour maintenant votre script “en vie” autrement il s’arrêtera automatiquement !

Constellation.StartAsync()
while Constellation.IsRunning:
    pass
    time.sleep(1)

Interpréteurs Python et environnements virtuels

Par défaut chaque script est lancé avec la commande “python”. C’est pour cela qu’il est recommandé d’ajouter Python dans le PATH de votre système afin de pouvoir “résoudre” la commande “python”.

Vous pouvez aussi définir dans le fichier App.config de votre package Python, l’attribut “pythonCmd” pour spécifier la commande à lancer. Ci-dessous un exemple avec l’interpréteur Python 2.7 :

<pythonProxy xmlns="urn:Constellation.PythonProxy" pythonCmd="C:\Python27\python.exe">
  <scripts>
    <script filename="Scripts\Demo.py" />
    <script filename="Scripts\Demo2.py" />
  </scripts>
</pythonProxy>

L’attribut “pythonCmd” peut-être également défini de manière individuelle pour chaque script. Prenez par exemple la configuration suivante :

<pythonProxy xmlns="urn:Constellation.PythonProxy" pythonCmd="python3">
  <scripts>
    <script filename="Scripts\Demo.py" />
    <script filename="Scripts\Demo2.py" pythonCmd="C:\Users\Sebastien\venv\Scripts\python.exe" />
    <script filename="Scripts\Demo3.py" pythonCmd="C:\Python27\python.exe" />
  </scripts>
</pythonProxy>

Ci-dessus le package Python démarre trois scripts Demo.py, Demo2.py et Demo3.py de la façon suivante :

• Demo.py sera lancé par l’interpréteur Python 3 (via la commande “python3” défini au niveau global)
• Demo2.py sera lancé par un environnement virtuel ici nommé “venv” (défini pour le script)
• Demo3.py sera lancé par l’interpréteur Python 2.7 installé dans “C:\Python27”

Vous pouvez donc utiliser cet attribut pour spécifier l’interpréteur Python à utiliser (Python 2 vs 3 ou même des interpréteurs dans des environnements virtuels). Quelque soit l’interpréteur utilisé n’oubliez d’installer les librairies “pyzmq” (et “enum34” si Python 2.x).

Note : vous pouvez aussi les Settings Constellation dans l’attribut « pythonCmd » vous permettant ainsi de définir/changer d’interpréteur sans modifier le code de votre package, simplement en manipulant les settings de votre package depuis la Console Constellation. Plus d’information sur ce billet.

Produire des logs

Pour écrire des logs dans le hub Constellation, tout comme en C#, vous disposez des méthodes suivantes :

• WriteInfo
• WriteWarn
• WriteError

Exemple :

Constellation.WriteInfo("Hello world from Python !")
Constellation.WriteWarn("This is a warning !")
Constellation.WriteError("This is an error !")

En Python vous pouvez formater vos messages avec des variables grâce à l’opérateur “%”.

Par exemple, affichons dans les logs Constellation l’état de notre package :

Constellation.WriteInfo("Hi I'm '%s' and I run on %s" % (Constellation.PackageName, Constellation.SentinelName))
Constellation.WriteInfo("IsConnected = %s | IsStandAlone = %s " % (Constellation.IsConnected, Constellation.IsStandAlone))

Vous remarquez par la même occasion quelques propriétés accessibles dans vos scripts Python (IsConnected, IsStandAlone, SentinelName, PackageName, etc…).

Accès aux settings

Le fonctionnement des settings est strictement identique à l’API .NET décrite ici.

Les settings sont définis sur le serveur au niveau du package ou via des groupes, et par héritage peuvent être définis dans le fichier local App.config et/ou dans le manifeste. Je vous invite vivement à lire cet article pour bien comprendre le fonctionnement des settings.

Avec l’API Python de Constellation vous disposez de la méthode “GetSetting” pour récupérer la valeur de vos settings.

Par exemple pour afficher la valeur du setting “Demo1” :

Constellation.WriteInfo("Demo1 = " + str(Constellation.GetSetting("Demo1")))

Si la valeur du setting n’existe pas, la méthode vous retourne un “Null” :

if Constellation.GetSetting("Demo1") <> Null:
     Constellation.WriteInfo("Demo1 = " + str(Constellation.GetSetting("Demo1")))

Vous avez également la possibilité d’attacher une méthode callback pour être notifier dans votre code Python lorsque les settings de votre packages sont mises à jour dans Constellation :

import Constellation

def OnSettingsUpdated():
    print("Mise à jour de mes settings depuis Constellation !!")

def Start():
    Constellation.OnSettingsUpdated = OnSettingsUpdated

Constellation.Start(Start);

Publier des StateObjects

Comme pour l’API .NET, vous disposez de la méthode PushStateObject pour publier un StateObject.

Chaque StateObject a obligatoirement un nom et une valeur de n’importe quel type :

Constellation.PushStateObject("MyString", "OK")
Constellation.PushStateObject("MyNumber", 123)
Constellation.PushStateObject("MyDecimal", 123.12)
Constellation.PushStateObject("MyBoolean", True)

Vous pouvez publier des StateObjects dont la valeur est un objet complexe :

Constellation.PushStateObject("Demo", { "UneString": "DemoPython", "UnNombre": 123 })

Dans l’exemple ce-dessus, le StateObject « Demo » est un objet contenant deux propriétés : « UneString » et « UnNombre ».

Lorsqu’il s’agit de type complexe, il est vivement conseiller de décrire le type du StateObject à Constellation.

Pour cela au démarrage de votre package (méthode Start), enregistrez vos différents types de StateObjects avec la méthode « DescribeStateObjectType ».

Par exemple :

Constellation.DescribeStateObjectType("MyStateObject", "StateObject à deux propriétés de démonstration", [
    { 'Name':'UneString', 'Type':'string', 'Description': 'Une chaine de caractère tout simplement' },        
    { 'Name':'UnNombre', 'Type':'int', 'Description': 'Un nombre entier' }
])

Pour chaque type on spécifiera un nom, une description du type et la liste ses propriétés. Sachant que pour chaque propriété nous avons un nom, un type et une description.

Le type d’une propriété peut faire elle-même référence à un autre type complexe que vous avez enregistré.

Pour finir il faudra déclarer le package descriptor après avoir décrit tous vos types :

Constellation.DeclarePackageDescriptor()

Enfin, pour chaque publication de StateObject, vous pouvez spécifier le type (simple ou complexe que vous aurez enregistré ci-dessus), un dictionnaire de méta-données ou encore une durée de vie (en seconde)  :

Constellation.PushStateObject("Demo", { "UneString": "DemoPython", "UnNombre": 123 }, type = "MyStateObject", metadatas = { "DeviceId": "RPi", "SerialNumber":"123" }, lifetime = 300)

Tester son package dans Visual Studio

Laissons le code de démo du script “Demo.py” créé par le Template du projet tel quel :

Notons simplement qu’au démarrage du package on enregistre la méthode “OnStart” pour :

• Produire différents logs via des “WriteInfo” (Warning & Error) contenant notamment différentes propriétés comme le IsConnected & IsStandalone.
• Publier le StateObject “Demo”

Debug local (hors Constellation)

Commençons par tester notre package hors Constellation en lançant simplement le package avec le bouton “Start” de Visual Studio (F5) :

Votre package démarre et vous pouvez suivre dans la console les différents logs produits par votre package.

Vous observerez que votre package n’est pas connecté à Constellation (IsConnected = false).

Debug dans Constellation

Maintenant lançons toujours le debugging de votre package Constellation depuis Visual Studio mais en connectant votre package à Constellation. (Assurez-vous d’avoir défini dans Visual Studio la Constellation à utiliser pour le debug comme nous l’avons vu dans ce guide).

Cette fois ci, votre package démarre dans Visual Studio mais en étant connecté à Constellation (IsConnected = true).

Vous pouvez donc suivre en temps réel les logs depuis la Console Constellation :

Vous retrouverez également dans le StateObject Explorer de la Console, le StateObject “Demo” publié par notre package :

Publiez votre package

Lorsque votre package est testé et validé, nous pouvons le publier dans Constellation.

Pour cela cliquez sur le bouton de publication :

Sélectionnez votre serveur Constellation cible et cliquez sur “Publish” :

Une fois publié, vous retrouverez votre package dans le “Package Repository” de la Console.

N’oubliez pas que vous pouvez personnaliser les différentes informations (nom du package, auteur, URL, version, description, etc…) en éditant le manifeste de votre package.

Déployez votre package sur une sentinelle

Maintenant que votre package est dans le catalogue de votre Constellation, vous pouvez le déployer sur autant de sentinelle que vous le souhaitez!

Par l’édition du fichier de configuration

Pour cela, vous pouvez éditer manuellement la configuration (via le Configuration Editor) pour ajouter une instance de package sur la sentinelle de votre choix par la ligne :

<package name="MonPackagePython" />

On peut également déclarer le setting “Demo1” pour cette instance de package :

<package name="MonPackagePython">
  <settings>
    <setting key="Demo1" value="Hello Python !!!!" />
  </settings>
</package>

Cliquez sur le bouton “Save & Deploy” et votre package sera automatiquement démarré sur la sentinelle ici nommée “PO-SWARIN” !

Par l’interface graphique de la Console Constellation

Autre moyen, plus intuitif et rapide pour déployer un package, cliquez sur le bouton “Deploy” dans menu contextuel de votre package Python :

Vous pouvez également cliquer sur le bouton “Deploy new package” sur la page “Packages”.

Un assistant vous proposera de sélectionner la sentinelle sur laquelle déployer votre package Python :

Si les settings de votre package sont déclarés dans le manifeste (voir ici), la Console vous affichera une fenêtre de paramétrage :

Une fois votre package déployé, vous pourrez suivre dans la Console Log votre package :

Et voilà votre premier package Python créé et déployé dans votre Constellation !

Next steps

• MessageCallback : exposer des méthodes Python dans la Constellation
• Envoyer des messages et invoquer des MessageCallbacks de la Constellation
• StateObjectLink : consommer des StateObjects de votre Constellation

The post Créez votre premier package Constellation en Python appeared first on Constellation.

Dans le menu principal de gauche, cliquez sur “Sentinels” :

Vous retrouverez sur cette page l’ensemble des sentinelles de votre Constellation.

Le statut peut être :

• Unknow : une sentinelle qui ne sait jamais connectée ou une sentinelle virtuelle
• Disconnected : une sentinelle qui est déconnectée après avoir été connecté
• Connected : la sentinelle est connectée

Dans le cadre d’une sentinelle réelle (connectée ou déconnectée) vous obtiendrez également la version de la sentinelle, du système d’exploitation et autres informations sur le moteur d’execution .NET.

Le bouton “Détails” permet d’afficher l’ensemble des informations d’une sentinelle :

Il s’agit d’un menu contextuel qui vous permettra également d’éditer les informations de connexion de la sentinelle, de la supprimer ou encore de voir ou ajouter des packages sur cette sentinelle :

Ajouter une sentinelle

Pour déclarer une sentinelle réelle ou virtuelle, cliquez sur le bouton “Add sentinel” :

Dans la fenêtre d’ajout saisissez le nom de votre sentinelle ainsi que le credential à utiliser pour la connexion :

Pour ajouter et gérer vos credentials, rendez-vous sur la page “Server Management > Credentials”.

Note : dans le cas d’une sentinelle Service, le nom par défaut est le nom de la machine (hostname Linux ou Windows) et dans le cas d’une sentinelle UI (pour Windows seulement), il s’agit du nom de la machine suivi du suffixe “_UI”. Notez toutefois que vous pouvez modifier le nom de la sentinelle dans la configuration de celle-ci. De plus les installeurs Windows et Linux des sentinelles utilisent l’API de Management pour enregistrer automatiquement la sentinelle au serveur, vous n’avez donc pas à l’ajouter manuellement. Cet écran servira surtout pour l’ajout de sentinelle virtuelle.

The post Gérer les sentinelles avec la Console Constellation appeared first on Constellation.