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.

Vous attendez quelqu’un chez vous mais vous êtes occupé à faire autre chose. Cette serrure connectée vous permettra de contrôler l’ouverture de la porte d’entrée depuis n’importe quelle pièce de votre domicile, et cela en un clic grâce à votre smartphone. Nous allons voir pas à pas comment la mettre en place simplement.

Prérequis

Pour réaliser ce projet, il vous faut :

• Une gâche électrique 12V / 500 A
• Un ESP8266
• Un régulateur de tension LM1117
• Un transistor NPN TIP 110
• Une résistance 5,6 KΩ
• Deux condensateurs 0,1 µF et 0,33 µF
• Du fil électrique
• Une batterie 12V
• Un serveur Constellation (Un ordinateur pourra faire l’affaire)

Etape 1 : réaliser une serrure connectée

Dans un premier temps, il nous a fallu trouver une serrure adaptée au développement du projet sur laquelle nous pouvions brancher nos fils électriques. Nous avons donc opté pour la serrure suivante que vous pourrez vous procurer via ce lien .

Pour de plus amples informations techniques sur la gâchette, vous pouvez également regarder ici.

Il faut ensuite créer le câblage nécessaire au fonctionnement de la serrure. Notre principal problème a été de convertir l’alimentation indispensable de 12V pour la serrure en une alimentation de 3,3V nécessaire à l’utilisation de notre ESP. A l’aide du régulateur de tension, nous avons réalisé le montage suivant en entrée de l’ESP.

Afin de laisser passer le courant et de faire fonctionner la gâchette, le transistor TIP110 en série avec une résistance 5,6kΩ se placent en sortie GPIO de l’ESP. Une LED peut être également placée à cette même sortie afin de visualiser l’état de la serrure.

Enfin, voici le montage final reprenant tous les composants :

Etape 2 : Programmation

Vous avez fait la moitié du travail, voyons ensemble comment coder notre ESP8266.

La fonction de base de la gâche électrique est assez simple : couper le courant à travers la serrure pour la fermer ou le laisser passer le courant afin d’ouvrir la serrure. En premier lieu, nous avons développé le code Arduino servant à faire faire passer du courant ou non dans la gâche. Pour cela nous devons dans un premier temps connecter notre ESP8266 à Constellation. Pour découvrir comment connecter votre ESP à Constellation, suivez ce guide.

En ce qui concerne le code Arduino permettant de contrôler la serrure, vous en trouverez ci-dessous l’intégralité.

#include <Constellation.h>

// ESP8266 Wifi
#include <ESP8266WiFi.h>
char ssid[] = "MY-WIFI";
char password[] = "xxxxxxxx";

define LOCK_PIN D3

// Constellation client
Constellation<WiFiClient> constellation("172.20.10.2", 8088, "d1mini", "demoisen", "xxxxxxxx");

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

  //SET I/O 
  pinMode(LOCK_PIN, OUTPUT);
  // INITIAL mode
  digitalWrite(LOCK_PIN , LOW);

  // Set Wifi mode
  if (WiFi.getMode() != WIFI_STA) {
    WiFi.mode(WIFI_STA);
    delay(10);
  }
  
  // Connecting 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());

  constellation.pushStateObject("State", false);
  
  constellation.registerMessageCallback("OpenDoor", MessageCallbackDescriptor().setDescription("Ouvres la porte"),
      [](JsonObject& message) {
            digitalWrite(LOCK_PIN, HIGH);
            constellation.pushStateObject("State", true);
            delay(4000);
            digitalWrite(LOCK_PIN, LOW);   
            constellation.pushStateObject("State", false);    
      });
  
  // Declare the package descriptor
  constellation.declarePackageDescriptor();

  // WriteLog info
  constellation.writeInfo("Virtual Package on '%s' is started !", constellation.getSentinelName());  
}

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

L’étape suivante a été d’utiliser la librairie Constellation pour ajouter un « MessageCallback » afin de contrôler le GPIO de la gâchette, couplé à un « StateObject » permettant de maintenir l’état de la serrure dans Constellation :

Constellation va aller garder en permanence l’état de la serrure grâce au StateObject « State ».

Dorénavant, n’importe qui connecté au serveur peut se servir du MessageCallback « OpenDoor» exposé par l’ESP que nous avons utilisé pour faire permuter l’ouverture et la fermeture automatique de la serrure. Un délai de 4 secondes est programmé avant que la serrure ne se referme après ouverture de la gâche. Nous avons ajouté cette fonctionnalité afin d’ajouter une partie sécurité à notre dispositif.

On obtient alors simplement le pilotage de notre gâchette avec Constellation, dont l’état pourra être contrôlé grâce à une page Web qu’on vous présente dans la partie suivante.

Etape 3 : Piloter sa serrure à l’aide d’une page web

Pour cette dernière étape qui consiste à piloter notre serrure connectée grâce à une page Web. Il s’agit principalement de l’interface via laquelle vous pourrez facilement décider de l’ouverture ou la fermeture de la serrure.

Voici le code HTML que nous avons mis en place :

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" ng-app="MyDemoApp">
<head>
    <link rel="stylesheet" href="bruh.css" />
    <title>Serrure connectée</title>
    <link rel="stylesheet" href="style.css" />
    <script type="text/javascript" src="https://code.jquery.com/jquery-2.2.4.min.js"></script>
    <script type="text/javascript" src="https://ajax.aspnetcdn.com/ajax/signalr/jquery.signalr-2.2.2.min.js"></script>
    <script type="text/javascript" src="https://cdn.myconstellation.io/js/Constellation-1.8.2.min.js"></script>
    <script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/angularjs/1.5.7/angular.min.js"></script>
    <script type="text/javascript" src="https://cdn.myconstellation.io/js/ngConstellation-1.8.2.min.js"></script>
    
    <script>
        var myDemoApp = angular.module('MyDemoApp', ['ngConstellation']);
        myDemoApp.controller('MyController', ['$scope',  'constellationConsumer', function ($scope, constellation) {
  
          constellation.initializeClient("http://172.20.10.2:8088", "xxxxxxxxxx", "WebPage");
          constellation.onConnectionStateChanged(function (change) {
            if (change.newState === $.signalR.connectionState.connected) {
                console.log("Je suis connecté !");
                constellation.requestSubscribeStateObjects("*", "DoorLock", "*", "*");
                }
            });

          constellation.onUpdateStateObject(function (stateObject) {
              console.log(stateObject);
              $scope[stateObject.Name] = stateObject.Value;
              $scope.$apply();
          });
          
          $scope.openDoor = function(){
                constellation.sendMessage({Scope: 'Package', Args: ['DoorLock']}, 'OpenDoor');
            };

            
          constellation.connect();

                }]);
    </script>
 
</head>

<body ng-controller="MyController">
        
    <button ng-click="openDoor()"> OPEN </button>

</body>
</html>

Avec quelques lignes de CSS, le rendu final de notre page est le suivant et on ne peut plus simple d’utilisation pour le pilotage :

Pour la suite il suffit d’héberger cette page HTML sur un serveur Web quelconque et vous pourrez ouvrir votre porte depuis un PC, un smartphone, une table ou autre.

Et comme l’ouverture de la porte est exposer comme un MessageCallback, vous pourrez l’ouvrir depusi un code C#, Python, Arduino ou même un simple appel HTTP à l’API Constellation. N’hésitez pas à utiliser le “Code Generator” de la console Constellation.

Au final avec une gâche électrique, un ESP8266, une Constellation et quelques lignes d’Arduino, on est capable d’ouvrir une porte depuis tous type d’application.

The post Créer une serrure connectée à Constellation appeared first on Constellation.

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

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

Prérequis

Pour ce tutoriel, il vous faut :

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

Etape 1 : Construire la prise

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

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

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

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

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

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

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

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

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

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

Etape 2 : la programmation

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Pour aller plus loin

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

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

The post Créer une prise connectée avec un ESP8266 appeared first on Constellation.

Introduction

Étudiants en 3^ème année à l’ISEN-Lille, nous avons eu l’idée de développer une boîte aux lettres connectée en utilisant la plateforme Constellation.

En réalisant ce projet, nous voulions proposer une solution de boîte aux lettres connectée à un prix raisonnable et possédant une interface fluide pour améliorer l’expérience de l’utilisateur. Pour cela, nous avons acheté des composants peu coûteux à placer sur notre boîte aux lettres, et développé une application Ionic.

Notre boîte aux lettres est connectée à la plateforme Constellation par le biais d’un ESP8266, vous pouvez le connecter facilement à votre Constellation en suivant cette documentation sur le site Constellation.

Nous détectons ensuite la présence de courriers à l’aide de capteurs à ultrasons.

Avec un lecteur de cartes NFC, nous contrôlons l’accès à notre boîte aux lettres. Celui-ci nous permet de savoir qui a ouvert la boîte aux lettres et donc d’envoyer les bonnes informations à notre Constellation. Le lecteur NFC nous permet également de vérifier qu’une carte ou qu’un badge a les autorisations nécessaires afin de commander l’ouverture via un servo-moteur.

L’application, développée avec le framework ionic nous permet d’offrir une interface utilisateur ergonomique. En la connectant à Constellation, l’utilisateur a accès à toutes les informations nécessaires très facilement.

La boîte aux lettres connectée

Prérequis : Avoir connecté l’ESP8266 à Constellation.

Composants utilisés

Pour connecter notre boîte aux lettres à Constellation, nous avons utilisé :

• Un ESP8266 D1 Mini (8€ sur Amazon)
• Des capteurs à ultrasons HC SR04 (3€ sur Amazon)
• Un lecteur de cartes NFC (8€ sur Amazon)
• Un servo-moteur (6€ sur eBay)

Voici la correspondance pour définir les différents pins avec cet ESP :

Etape 1 : Détecter la présence d’une lettre grâce à un capteur ultrason

Nos capteurs fonctionnent avec une alimentation de 5V

Les capteurs à ultrasons nous permettent de mesurer une distance en créant une impulsion sur une des broches. Grâce à cette mesure, nous pouvons détecter une variation de la distance lorsqu’un courrier et inséré dans la boîte aux lettres. Nous envoyons alors l’information à Constellation grâce à un MessageCallback.

Relier le capteur à notre ESP est assez simple, notre capteur à ultrasons possède 4 branches, chacune branchée sur un pin de notre ESP.

Ci-dessous, les correspondances entre les branches du capteur à ultrasons et les pins de l’ESP8266 :

Dans notre code, nous configurons les pins dans le setup afin de préparer l’impulsion.

void setup() {
   pinMode(TRIGGER, OUTPUT);
   digitalWrite(TRIGGER, LOW); //La broche TRIGGER doit être à LOW au repos
   pinMode(ECHO, INPUT);
   Serial.begin(9600);
 }

Nous envoyons ensuite de façon continue des impulsions pour savoir si un obstacle est présent puis, s’il y en a un, nous envoyons un Message Callback.

void loop() {    
    /* 1. Lance une mesure de distance en envoyant une impulsion HIGH de 10 µs sur la broche TRIGGER */
   digitalWrite(TRIGGER, HIGH);
   delayMicroseconds(10);
   digitalWrite(TRIGGER, LOW);
   
   /* 2. Mesure le temps entre l'envoi de l'impulsion ultrasonore et son écho (s'il existe) */
   long measure = pulseIn(ECHO, HIGH);                
                                                                                 
   /* 3. Calcul la distance à partir du temps mesuré */
   long distanceMeasured = measure *vitesse ;
  
   /* 4. Envoie d'un MessageCallback à Constellation si on rentre dans le if */ 
   if(distanceMeasured < defaultValue){
     constellation.sendMessage(Package, "Brain", "message");
   }
}

Etape 2 : Gérer les accès à la boîte aux lettres grâce à un lecteur de carte NFC

Dans cette partie, nous allons envoyer un Message Callback à Constellation grâce à l’ID du badge NFC détecté par notre lecteur de cartes.

Cela nous permettra par la suite de gérer les autorisations d’accès à la boîte aux lettres, de contrôler l’ouverture par notre servo-moteur, et d’avertir l’utilisateur qu’un colis a été livré ou que le courrier a été récupéré. Nous devrons donc enregistrer les différents utilisateurs en renseignant leur ID de badge et leur statut (facteur ou utilisateur).

Voici le câblage réalisé pour cette partie entre le NFC et l’ESP :

Il faut commencer par télécharger la bibliothèque suivante :

Voici ensuite la fonction nécessaire à l’envoi d’un Message Callback lorsque nous captons un nouveau badge.

void NFC() {
    // Regarde s'il y a une nouvelle carte, s'il n'y en a pas on quitte la fonction
    if ( ! mfrc522.PICC_IsNewCardPresent()) {
        return;
    }
    // S'il n'arrive pas à lire la carte on quitte la fonction
    if ( ! mfrc522.PICC_ReadCardSerial()) {
        return;
    }
    char sochar[256]; // 256 correspond à un octet
    String UID= dump_byte_array(mfrc522.uid.uidByte, mfrc522.uid.size); 
    /* Permet de transformer un tableau de bit en String */
    UID.toCharArray(sochar, 256);
    constellation.sendMessage(Package, "Brain", "Authorisation", sochar); /* envoie un message Callback du package Brain appelé Authorisation*/
}

Etape 3 : Ouvrir et fermer la porte grâce à un servo-moteur

Le servomoteur va nous servir à commander notre verrou. Ce dernier va donc s’abonner à un State Object nous donnant l’état de la porte (verrouillée ou déverrouillée). Ainsi, lorsque notre lecteur NFC captera un ID autorisé, notre State Object changera, ainsi que l’état de verrouillage de la porte.

Voici les branchements qui relient notre moteur à l’ESP :

Avant d’utiliser le code ci-dessous, il faut vérifier que vous avez bien installé les bibliothèques suivantes :

Dans le Setup ci-dessous, nous nous abonnons à un StateObject qui nous permet d’ouvrir et de fermer la porte lorsqu’il change d’état.

void setup() {
    monServo.attach(15); // Définit le moteur au D8
    monServo.write(0); // ServoMoteur à sa position initiale
    constellation.registerStateObjectLink("*", "Brain", "Porte_ouverte", [](JsonObject& so) {
     delay(100); // délai afin d'attendre la connexion à  Constellation
     if (so["Value"]== true){   
       monServo.write(90);  // Position de la porte ouverte
       }
 
    if (so["Value"]== false){
       monServo.write(0);   // Position de la porte fermée
       }
       delay(3000); // attendre au minimum 3 secs avant que la porte ne change d'état.
   });  
 }

Etape 4 : Synchroniser toutes nos parties avec un package Constellation

Vous pouvez retrouver notre code complet pour la boîte aux lettres sur GitHub pour plus de précision (https://github.com/Sqyluck/Boite-aux-lettres-connectee).

Il est ensuite nécessaire de créer un package Constellation, qui va nous permettre de traiter toutes les données de nos différents éléments.

→ Voici les différents Message Callbacks créent dans le package afin de répondre à nos besoins.

→ Voici la liste des State Objects générés par le package pour permettre l’affichage de nos données dans l’application et l’envoi d’ordre au servomoteur via l’ESP8266.

Etape 5 : Fabrication de la boîte aux lettres

Nous avons utilisé des planches en bois afin de réaliser notre boîte aux lettres. Nous avons vissé les planches entre elles, puis nous avons fixé nos éléments sous le toit de la boîte.

L’interface utilisateur

Prérequis : disposer de Node.js et de npm

Etape 1 : Créer une application avec ionic

Afin de réaliser notre interface utilisateur, nous avons décidé dans un premier temps de développer notre application avec Ionic 2 dans Visual Studio. Mais avec cette méthode nous étions obligé de développer notre application en langage typescript ce qui était plus compliqué pour connecter l’application à la plateforme Constellation. Nous avons donc décidé d’utiliser Ionic 1 afin de développer notre application en javascript et de la connecter plus facilement.

Avant de commencer, il faut lancer l’installation de Ionic 1 depuis l’invite de commande :

npm install – g cordova ionic

(Attention : cette commande ne fonctionnera pas si vous ne disposez pas auparavant de node.js et de npm)

Une fois que nous nous sommes placé dans le dossier dans lequel nous souhaitons développer notre application, nous pouvons utiliser la commande suivante pour lancer la création d’un nouveau projet.

ionic start myApp tabs --type ionic1

(Nous venons ici de créer un nouveau projet ionic 1 de type tabs intitulé myApp)

Dans l’invite de commande, placez-vous dans le dossier de l’application (en utilisant la commande cd).

La commande ionic serve permet d’exécuter l’application dans un navigateur.

Lorsque le projet est créé, vous devez éditer vos différentes pages (par ex. sur Notepad++). Les fichiers à modifier se trouvent dans le dossier « www » :

• Le fichier index.html
• Les fichiers .html appartenant au dossier “templates” → C’est ici que vous pouvez modifier le contenu de chaque page de votre application.
• Le fichier app.js dans le dossier “js” → Vous devez définir votre constellation à cet endroit.
• Le fichier controllers.js dans le dossier “js” → Chaque controller est associé à une page html. Vous pouvez utiliser les variables et les fonctions définies dans ces pages grâce aux “Scopes”.

Etape 2 : Visualiser notre application sur un smartphone

Si vous souhaitez utiliser votre application sur votre smartphone, vous pouvez utiliser l’application “ionic view” disponible sur l’App Store et Google Play. Cette application vous permettra de visualiser directement l’application que vous êtes en train de développer sur votre smartphone.

Une fois l’application installée, vous devez ensuite vous rendre sur ce site, créer un compte, puis cliquez sur “New App”. Il ne vous reste plus qu’à faire le lien avec votre application et l’envoyer sur votre appareil. Pour cela, dans le dossier de votre application, utilisez les deux commandes suivantes dans votre invite de commande

ionic link 
ionic upload

Ouvrez ensuite ionic view et visualisez votre application.

Vous pouvez également, après avoir branché votre téléphone et avoir activé le mode debug, utiliser la commande cordova run android afin de simuler directement votre application sur votre téléphone android.

Etape 3 : Connecter notre application à constellation

Afin de connecter notre application à la plateforme constellation, nous allons modifier le fichier app.js ainsi que le index.html.

Pour cela, nous allons importer les bibliothèques suivantes dans le fichier index.html :

• jquery-2.2.4.min.js
• jquery.signalr-2.2.1.min.js
• Constellation-1.8.1.min.js
• ngConstellation-1.8.1.min.js

Les librairies sont disponibles sur cette page. Nous vous conseillons de créer un dossier intitulé constellation dans le dossier « lib » et d’y enregistrer ces différentes bibliothèques.

Il ne vous restera plus qu’à ajouter les lignes de code suivantes dans le fichier index.html :

<script type="text/javascript" src="lib/constellation/jquery-2.2.4.min.js"></script>
<script type="text/javascript" src="lib/constellation/jquery.signalr-2.2.1.min.js"></script>
<script type="text/javascript" src="lib/constellation/Constellation-1.8.1.min.js"></script>
<script type="text/javascript" src="lib/constellation/ngConstellation-1.8.1.min.js"></script>

Puis nous allons ajouter le code suivant à notre fichier app.js :

1. Modifier la ligne angular.module, y ajouter ‘ngConstellation’ comme ci-dessous :

angular.module('starter', ['ionic', 'starter.controllers', 'ngConstellation'])

2. Modifier la fonction .run, y ajouter $rootScope et constellationConsumer :

.run(function($ionicPlatform, $rootScope, constellationConsumer)

3. Ajouter le code suivant dans la fonction .run :

constellationConsumer.initializeClient("http://192.168.43.171:8088", "123456789", "Application Ionic");
    constellationConsumer.onConnectionStateChanged(function (change) {
        if (change.newState === $.signalR.connectionState.connected) {
            console.log("Connecté à constellation");
            $rootScope.isConnected = true;
        }
    });
    constellationConsumer.connect();
    $rootScope.constellation = constellationConsumer;

Vous pouvez maintenant vérifier que vous êtes bien connecté à votre constellation en regardant dans votre console (f12 dans votre navigateur).

Etape 4 : Connecter notre application à la boîte aux lettres

Un certain nombre de State Objects et de Message Callbacks ont été réalisés dans notre package constellation afin de traiter nos différentes informations (ce package est disponible sur gitHub).

Le rôle de notre application ici est simplement de s’abonner aux State Objects et d’envoyer des messages Callbacks à notre constellation.

→ Exemple de récupération d’un State Object :

Les StateObjects se récupèrent dans le fichier app.js, à l’endroit où nous avons défini notre constellation. Voici un exemple de code correspondant à notre State Object « Users » :

//State Object Utilisateurs
constellationConsumer.registerStateObjectLink("*", "Brain", "Users", "*", function(so) {
    $rootScope.Users = so.Value;
    $rootScope.$apply();
});

Pour afficher nos utlisateurs, il nous suffit maintenant, dans notre page html d’utiliser le code suivant :

<ion-item ng-repeat="user in Users">
  <h2>{{user.firstName}} {{user.name}}</h2>
  <p>{{user.client ? "client":"facteur"}}</p>
</ion-item>

→ Exemple d’envoi d’un message Callback :

Les messages Callbacks s’envoient dans le fichier controllers.js. Voici l’exemple de code pour le Message Callback « DeleteUser » :

//Message CallBack DeleteUser
$scope.name = $stateParams.name
$scope.firstName = $stateParams.firstName;
$scope.deleteUser = function() {
    var deleteUser = $ionicPopup.confirm({
      title: 'Supprimer cet utilisateur',
      template: 'Etes vous sur de vouloir supprimer cet utilisateur ?'
    });
    deleteUser.then(function(res) {
      if(res) {
          $rootScope.constellation.sendMessage({ Scope: 'Package', Args: ['Brain'] }, 'DeleteUser', [$scope.firstName, $scope.name ]);
          $state.go('tab.utilisateurs');
          console.log('deleted');
      } 
      else {
          console.log('do nothing');
      }
    });
};

Dans notre page html, on appelle maintenant la fonction créée dans notre controller.js dans un bouton par exemple :

<button ng-click="deleteUser()">Supprimer cet utilisateur</button>

En vous servant de cette base, vous pouvez réaliser une application vous permettant de recevoir un message sur votre application lorsque vous recevez un courrier ou un colis mais aussi d’ajouter ou de supprimer des accès à la boite aux lettres.

Il est également possible de réutiliser des packages existants, par exemple, nous nous sommes servis du package PushBullet afin de recevoir des notifications sur notre smartphone.

Voici un aperçu de notre application ionic :

The post Créer une boite aux lettres connectée avec Constellation appeared first on Constellation.

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

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

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

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

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

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

Prerequis

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

Etape 1 : connecter le vidéo projecteur dans Constellation

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

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

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

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

Aussi simple que cela !

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Conclusion

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

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

The post Connecter un vidéo projecteur standard à Constellation et synchroniser les volets appeared first on Constellation.

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 cela nous allons utiliser une matrice de 8×8 LEDs pilotable en I²C que vous pouvez trouver chez Adafruit pour environ 15€. Pour piloter cette matrice nous allons utiliser un ESP8266, ici un D1 Mini Pro (environ 6€).

Prérequis

Pour réaliser ce tutoriel, vous aurez besoin :

• Un serveur Constellation
• Un ESP8266
• Une matrice de LED I²C

Si c’est la première fois que vous utilisez un ESP8266 connecté à Constellation, je vous recommande de suivre ce guide d’introduction avant de commencer !

Etape 1 : connecter la matrice de LED

Nous avons ici utilisé un D1 Mini Pro, un ESP8266 intégrant nativement une interface de programmation USB, très pratique pour créer des prototypes rapides.

La matrice de LED se connecte à l’ESP8266 en I²C. Nous avons utilisé les fils Noir et Blanc pour alimenter la matrice depuis les pins “5V” et “GND” du D1 Mini ainsi que les fils Bleu et Vert pour connecter les ports D1 et D2 du D1 Mini aux ports SCL et SDA de la matrice de LED :

Et voilà le montage est déjà fini ! Vous pouvez maintenant connecter votre D1 Mini en USB à votre PC pour 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 « MatrixController ».

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", "MatrixController", "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 les librairies d’Adafruit pour piloter la matrice de LED bicolore.

Dans le gestionnaire de bibliothèque (menu Croquis > Inclure une bibliothèque), installez les librairies suivantes :

• Adafruit GFX
• Adafruit LED Backpack

Puis dans votre code, ajoutez ces librairies et déclarez une variable de type « Adafruit_BicolorMatrix » que nous nommerons « matrix » :

#include "Adafruit_LEDBackpack.h"
#include "Adafruit_GFX.h"
#include <Wire.h>
Adafruit_BicolorMatrix matrix = Adafruit_BicolorMatrix();

Au démarrage, dans la méthode « setup() », initialisez la matrice de LED. Pour rappel nous avons branché la matrice I²C sur les ports D1 et D2 :

// Init matrix led
Wire.begin(D1, D2);
matrix.begin(0x70);

Toujours dans la méthode d’initialisation, enregistrons un premier MessageCallback que nous allons nommer « SetPixel ». Ce MessageCallback permettra d’allumer ou éteindre un pixel de la matrice.

Nous le déclarons avec 4 paramètres d’entrée :

• x et y pour définir la position du pixel à piloter
• state : un boolean indiquant si le pixel doit être allumé ou éteint
• clear: un paramètre optionnel de type boolean pour indiquer si il faut effacer la matrice avant (par défaut « true »)

Comme vous le constatez ci-dessous, le code de ce MessageCallback commence par effacer la matrice si le dernière paramètre (clear) n’est pas défini (car optionnel) ou si il est à « true » en invoquant la méthode « matrix.clear()« .

Ensuite on appelle la méthode « drawPixel » en passant les arguments de notre MC, à savoir le « x », le « y » et le « state ».

Si le paramètre « state » est vrai, on allume le pixel en vert (LED_GREEN) sinon on l’éteint (LED_OFF).

Le code est donc :

// Register SetPixel
constellation.registerMessageCallback("SetPixel",
  MessageCallbackDescriptor().setDescription("Set Pixel On or Off").addParameter<int>("x").addParameter<int>("y").addParameter<bool>("state", "ON or OFF").addOptionalParameter<bool>("clear", true, "Clear matrix before drawn"),
  [](JsonObject& json) {
    if(json["Data"].size() < 4 || json["Data"][3].as<bool>()) {
      matrix.clear();
    }
    matrix.drawPixel(json["Data"][0].as<int>(), json["Data"][1].as<int>(), json["Data"][2].as<bool>() ? LED_GREEN : LED_OFF);  
    matrix.writeDisplay();
 });

Comme il s’agit d’une matrice bicolore, on peut allumer chaque pixel en vert ou en rouge, ou bien en vert ET en rouge ce qui donne du orange.

Nous allons donc ajouter un deuxième MessageCallback que nous nommerons « SetPixelColor » sensiblement identique au premier, sauf que le paramètre « state » est maintenant de type  « int » et se nomme « color ».

D’après les constantes de la librairie d’Adafruit, LED_GREEN = 2, LED_OFF = 0, le rouge (LED_RED) = 1 et le Orange/Jaune = 2. Le code est donc :

// Register SetPixelColor
constellation.registerMessageCallback("SetPixelColor",
  MessageCallbackDescriptor().setDescription("Set Pixel On or Off").addParameter<int>("x").addParameter<int>("y").addParameter<int>("color", "0 = Off, 1 = red, 2 = orange, 3 = green").addOptionalParameter<bool>("clear", true, "Clear matrix before drawn"),
  [](JsonObject& json) {
    if(json["Data"].size() < 4 || json["Data"][3].as<bool>()) {
      matrix.clear();
    }
    matrix.drawPixel(json["Data"][0].as<int>(), json["Data"][1].as<int>(), json["Data"][2].as<int>());  
    matrix.writeDisplay();
 });

Pour finir, ajoutons un troisième et dernier MessageCallback pour effacer l’écran :

// Register Clear
constellation.registerMessageCallback("Clear",
  MessageCallbackDescriptor().setDescription("Clear matrix"),
  [](JsonObject& json) {
    matrix.clear();
    matrix.writeDisplay();
 });

Vous pouvez téléverser le programme puis en vous connectant sur le MessageCallbacks Explorer de la Console Constellation vous constaterez que les trois MessageCallbacks sont bien référencés dans votre Constellation.

Votre ESP8266 est prêt ! Vous pouvez tester les MC directement depuis la Console pour vous assurer que tout fonctionne correctement :

Par exemple en invoquant le MessageCallback « SetPixel » avec x=1, y=2 et state=true, le résultat est instantanément visible sur la matrice :

Etape 3 : créer une page Web

Maintenant que notre matrice connectée est prête, créons une page Web pour pouvoir la piloter.

Pour cela nous allons créer une grille de 8×8 représentant la matrice sur laquelle nous pourrions dessiner à la sourie ou au droit (touch) avec la possibilité de choisir la couleur entre le verte, le roue et le orange. Nous allons utiliser le Canvas HTML5 pour cela.

Inutile d’utiliser le framework AngularJS pour cela, nous utiliserons la librairie Constellation pour Javascript.

Commençons donc par créer une page HTML classique dans laquelle ajoutons dans l’entête <head> les scripts nécessaires pour connecter la page à Constellation :

<meta name="viewport" content="width=device-width" />
<script type="text/javascript" src="https://code.jquery.com/jquery-2.2.4.min.js"></script>
<script type="text/javascript" src="https://ajax.aspnetcdn.com/ajax/signalr/jquery.signalr-2.2.1.min.js"></script>
<script type="text/javascript" src="https://cdn.myconstellation.io/js/Constellation-1.8.1.min.js"></script>

Nous avons également ajouté la meta « viewport » pour adapter proprement notre page sur un mobile.

Dans le corps <body> de notre page ajoutons un canvas pour la grille, la liste des couleurs possibles et un bouton pour effacer l’écran :

<canvas id="canvas" width="400" height="400"></canvas>

<ul id="colors">
    <li><a href="#" data-colorId="0" data-color="white">Eraser</a></li>
    <li><a href="#" data-colorId="1" data-color="red" class="selected">Rouge</a></li>
    <li><a href="#" data-colorId="2" data-color="orange">Orange</a></li>
    <li><a href="#" data-colorId="3" data-color="green">Vert</a></li>
</ul>

<button id="clear">Clear</button>

Vous remarquerez que nous stockons dans des attributs « data- » l’ID de la couleur de la matrice de LED (0 à 3) et le nom de la couleur HTML équivalente (ex. red = 1). La couleur sélectionnée est repérée par la classe CSS « selected ».

Pour la mise en page justement, ajoutez le code CSS dans une balise <style> dans la page :

body {
    text-align:center; 
    background:#e9e9e9
}        
#canvas {
    margin:0 auto 20px auto; 
    display:block; 
    background:#fff; 
    cursor:crosshair
}
#colors {
    list-style:none; 
    margin:0 0 20px 0;
    padding:0
}
#colors li {
    display:inline-block
}
#colors a {
    display:inline-block; 
    width:50px; 
    height:50px; 
    margin-right:10px; 
    text-indent:-4000px; 
    overflow:hidden; 
    border-radius:50%
}
#colors a.selected {
    border:2px solid #000; 
    width:45px; 
    height:45px
}
button {
  border-radius: 8px;
  padding: 10px 20px 10px 20px;
  color: #ffffff;
  font-size: 20px;
  background: #808080;
}

Enfin, passons au code Javascript de notre page. Ouvrez une balise <script> pour ajouter le code ci-dessous.

On commence tout d’abord par déclarer la taille de notre matrice (8×8) ainsi que le client « consumer » de Constellation en spécifiant l’adresse/port de votre serveur Constellation ainsi qu’une clé d’accès pour pouvoir s’y connecter.

Ensuite on déclare les variables globales de notre script.

// Config
var matrixWidth = 8, matrixHeight = 8;
var constellation = $.signalR.createConstellationConsumer("http://x.x.x.x:8088/", "xxxxxxxxxxxxxx", "WebMatrixController"); 

// Global variables
var pixels = [];
var selectedColor = {};
var mouseDown = false;
var canvas, context;
var boxWidth, boxHeight;

On ajoute une fonction « initBoard » pour dessiner notre grille dans le canvas HTML et initialiser le tableau « pixels » qui contiendra l’état de la matrice :

function initBoard() {
    // Init the pixels array
    pixels = [];
    for (var x = 0; x <= matrixWidth; x++) {
        pixels[x] = [];
        for (var y = 0; y <= matrixHeight; y++) {
            pixels[x][y] = 0;
        }
    }
    // Create the vertical lines
    for (var x = 0; x <= matrixWidth; x++) {
        context.moveTo(1 + x * boxWidth, 0);
        context.lineTo(1 + x * boxWidth, canvas.height());
    }
    // Create the horizontal lines
    for (var x = 0; x <= matrixHeight; x++) {
        context.moveTo(0, 1 + x * boxHeight);
        context.lineTo(canvas.width(), 1 + x * boxHeight);
    }
    // Draw lines
    context.lineWidth=1;
    context.strokeStyle = "black";
    context.stroke();
}

On déclare ensuite une fonction « setPixel » qui se chargera à la fois de dessiner dans le canvas la couleur sélectionnée du pixel mais également d’envoyer un message à notre ESP8266 pour invoquer le MessageCallback « SetPixelColor » en spécifiant la position du pixel et la couleur sélectionnée. Le tableau « pixel » permet de n’envoyer le message que si la couleur a changé pour éviter d’envoyer plusieurs fois le même ordre.

function setPixel(x, y) {
    if(pixels[x][y] != selectedColor.color) {
        // Save pixel
        pixels[x][y] = selectedColor.color;
        // Draw on canvas
        context.fillStyle=selectedColor.color;
        context.fillRect(2 + boxWidth * x, 2 +  boxHeight * y, boxWidth - 2, boxHeight - 2);
        // SetPixelColor on ESP8266
        constellation.server.sendMessage({ Scope: 'Package', Args: ['MatrixDesign'] }, 'SetPixelColor', [ x, y, selectedColor.id ]);  
    }
}

Pour l’interaction nous ajoutons trois méthodes :

• moveStart : lorsque la sourie/le doigt (si touch) est posé sur la grille
• move : lorsque la sourie/le doigt (si touch) se déplace sur la grille
• moveEnd : lorsque la sourie/le doigt (si touch) « quitte » la grille

Dans les deux premières méthodes l’idée est de déduire la position du pixel en fonction des arguments de l’événement levé afin d’invoquer la méthode « setPixel » que nous avons déclarée ci-dessus qui se chargera à son tour de dessiner la bonne couleur dans le canvas tout envoyant le message à notre ESP8266.

function moveStart(e, mobile, obj) {
    mouseDown = true;
    // Determine the pixel coordinates
    var event = mobile ? e.originalEvent : e;
    var x = Math.trunc((event.pageX - obj.offsetLeft) / boxWidth);
    var y = Math.trunc((event.pageY - obj.offsetTop) / boxHeight);
    // Block mobile event
    if (mobile) {
        e.preventDefault();
    }        
    // Set pixel
    setPixel(x, y);
}

function move(e, mobile, obj) {
    if (mouseDown) {
        // Determine the pixel coordinates
        var pageX = mobile ? e.originalEvent.targetTouches[0].pageX : e.pageX;
        var pageY = mobile ? e.originalEvent.targetTouches[0].pageY : e.pageY;
        var x = Math.trunc((pageX - obj.offsetLeft) / boxWidth);
        var y = Math.trunc((pageY - obj.offsetTop) / boxHeight);
        // Block mobile event                
        if (mobile) {
            e.preventDefault();
        }     
        // Set pixel
        setPixel(x, y);
    }
}

function moveEnd() {
    mouseDown = false;
}

Il ne reste plus qu’à écrire le code de démarrage de notre page.

On commence par initialiser nos variables globales (instance et taille du canvas, contexte de rendu 2D du canvas). On initialise ensuite la grille par notre méthode « iniBoard » et on se connecte à notre Constellation (constellation.connection.start()).

Pour chaque couleur de notre liste, on affecte la couleur du background définie par son attribut data-color et on ajoute un handler au click de façon à récupéré dans l’objet « selectedColor » la couleur sélectionnée par l’utilisateur.

On affecte également un handler au click du bouton « Clear » pour effacer le Canvas et invoquer le MessageCallback « clear » sur notre ESP8266 afin de vider la matrice.

Et pour finir on attache des handlers aux événements de la souris (mouseDown, mouseMove et mouseUp) et du tactile (touchStart, touchMove et touchEnd) sur nos tris méthodes ci-dessus pour gérer les interactions avec notre grille.

// On page load
$(document).ready(function() {
    // Variables
    canvas = $("#canvas");
    context = canvas[0].getContext('2d');
    boxWidth = (canvas.width() - 2) / matrixWidth;
    boxHeight = (canvas.height() - 2) / matrixHeight;
    // Init board
    initBoard();            
    // Constellation connection
    constellation.connection.stateChanged(function (change) {
        if (change.newState === $.signalR.connectionState.connected) {
            console.log("Je suis connecté !");
        }
    });                
    constellation.connection.start();            
    // For each color buttons
    $("#colors a").each(function() {
        // Set background color
        $(this).css("background", $(this).attr("data-color"));
        // Attach handler on click
        $(this).click(function() {
            // Load the selected color
            selectedColor.id = $(this).attr("data-colorId");
            selectedColor.color = $(this).attr("data-color");
            // Set the selected class
            $("#colors a").removeAttr("class", "");
            $(this).attr("class", "selected");
            return false;                    
        });
        // Load the selected color
        if( $(this).attr("class") == "selected") {
            selectedColor.id = $(this).attr("data-colorId");
            selectedColor.color = $(this).attr("data-color");
        }
    });            
    // Clear button
     $("#clear").click(function() {
        // Clear the matrix
        constellation.server.sendMessage({ Scope: 'Package', Args: ['MatrixDesign'] }, 'Clear', {});
        // Clear the canvas
        var s = document.getElementById ("canvas");
        var w = s.width;    
        s.width = 10;
        s.width = w;
        // Redraw the board
        initBoard();                
     });             
     // Attach Touch events
    canvas.bind('touchstart', function(e) { moveStart(e, true, this); });
    canvas.bind('touchmove', function(e) { move(e, true, this); });
    $(this).bind('touchend', function() { moveEnd(); });
    // Attach Mouse events
    canvas.mousedown(function(e) {  moveStart(e, false, this); });
    canvas.mousemove(function(e) { move(e, false, this); });
    $(this).mouseup(function() { moveEnd(); });
});

Et voilà notre page HTML est prête ! Lancez-la dans notre navigateur et profitez du résultat.

Demos

Quelques démonstrations animées ….

The post Pilotez une matrice de LED avec une page Web en temps réel 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.

Prérequis

• Un Arduino connecté ou un ESP8266
• Des capteurs (DHT11 pour l’humidité et la température, un TSL2561 pour la luminosité par exemple)
• Un serveur Constellation

Etape 1 : le montage

Ici nous utiliserons un D1 Mini Pro (ESP8266) avec un capteur DHT11 combinant la mesure de la température et de l’humidité ainsi qu’un capteur TSL2561 pour la luminosité.

Les deux capteurs seront alimentés en 3,3v par la D1 Mini.

Le TSL2561 dispose d’une interface I²C (SDA et SDL qu’on connectera sur D1 et D2) et le DHT11 n’a besoin que d’une entrée digitale (qu’on connectera sur D3).

Etape 2 : la programmation

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 “MySensor”.

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", "MySensor", "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.

Lancez maintenant le « gestionnaire de bibliothèque » (menu Croquis > Inclure une bibliothèque > Gérer les bibliothèques) et installez les bibliothèques suivantes :

• Adafruit Unified Sensor (par Adafruit)
• DHT Sensor library (par Adafruit)
• Adafruit TSL2561 (par Adafruit)

Une fois les librairies installées, ajoutez en entête de votre code :

#include <Adafruit_TSL2561_U.h>
#include <DHT_U.h>
#include <Wire.h>

Déclarez ensuite, juste après la déclaration du client Constellation, le capteur TSL2561 et le DHT11 par les lignes :

DHT_Unified dht(D3, DHT11);
Adafruit_TSL2561_Unified tsl(TSL2561_ADDR_FLOAT);

Déclarez également un entier pour définir l’intervalle de temps (en ms) entre deux mesures que nous fixons à 10 secondes par défaut :

int interval = 10000; //ms

Dans la méthode « setup() » configurez les I/O utilisés par l’I²C (D1 et D2 dans notre cas) :

Wire.begin(D1, D2);

Initialisez ensuite le capteur DHT11 par la ligne :

dht.begin();

Puis le capteur TSL2561 :

if(!tsl.begin())
{
  Serial.print("No TSL2561 detected!");
  while(1);
}
tsl.enableAutoRange(true);
tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_13MS);

Toujours dans la méthode « setup », récupérons les settings de notre package sur Constellation et affectons le setting « Interval » si défini sur Constellation (autrement c’est la valeur de 10 secondes déclarée ci-dessus qui sera utilisée) :

JsonObject& settings = constellation.getSettings();
if(settings.containsKey("Interval")) {
  interval = settings["Interval"].as<int>();
}

Pour finir dans la boucle principale, nous allons prendre les mesures de nos capteurs et publier trois StateObjects avec une durée de vie de deux fois l’intervalle de temps :

void loop(void) {
  constellation.loop();
  static int lastBeat = 0;
  if(millis() - lastBeat > interval) {
    lastBeat = millis();
    sensors_event_t event;
    // Luminosité
    tsl.getEvent(&event);
    if (event.light) {
      constellation.pushStateObject("Light", event.light, interval * 2);
    }  
    // Temperature
    dht.temperature().getEvent(&event);
    if (!isnan(event.temperature)) {
      constellation.pushStateObject("Temperature", event.temperature, interval * 2);
    }
    // Humidité
    dht.humidity().getEvent(&event);
    if (!isnan(event.relative_humidity)) {
      constellation.pushStateObject("Humidity", event.relative_humidity, interval * 2);
    }
  }
}

Et voilà votre capteur connecté est prêt !

Il ne reste plus qu’à téléverser votre programme et ouvrir votre Console Constellation pour constater qu’il est bien opérationnel :

Ouvrez maintenant le StateObject Explorer et rechercher le terme “MySensor” :

On retrouve bien, en temps réel, les trois mesures réalisées par notre ESP8266. N’hésitez pas à ouvrir ces StateObjects et cliquez sur « Subscribe » pour voir les mesures en temps réel dans la Console Constellation.

Etape 3 : Une page Web pour afficher votre capteur en temps réel

Créons maintenant une page Web pour afficher en temps réel les mesures de notre capteur connecté. Pour cela créez un fichier HTML sur votre poste avec une structure HTML de base.

Dans les entêtes ajoutez les scripts suivants :

<script type="text/javascript" src="https://code.jquery.com/jquery-2.2.4.min.js"></script>
<script type="text/javascript" src="https://ajax.aspnetcdn.com/ajax/signalr/jquery.signalr-2.2.1.min.js"></script>
<script type="text/javascript" src="https:/cdn.myconstellation.io/js/Constellation-1.8.1.min.js"></script>
<script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/angularjs/1.5.7/angular.min.js"></script>
<script type="text/javascript" src="https://cdn.myconstellation.io/js/ngConstellation-1.8.1.min.js"></script>

Sur la balise <html> ajoutez l’attribut :

ng-app="MyDemoApp"

Et sur la balise <body> ajoutez l’attribut :

ng-controller="MyController"

Dans le corps de votre page, placez les valeurs vos StateObjects où bon vous semble. Par exemple :

<div>
    Temperature: <p>{{Temperature}}°C</p>
    Humidity: <p>{{Humidity}}%</p>
    Light: <p>{{Light}} lux</p>
</div>

Pour finir ajoutez le script suivant dans votre page (dans une balise <script>):

var myDemoApp = angular.module('MyDemoApp', ['ngConstellation']);
myDemoApp.controller('MyController', ['$scope', 'constellationConsumer', function ($scope, constellation) {

  constellation.initializeClient("http://localhost:8088", "clé d'accès constellation", "MySensor WebPage");

    constellation.onConnectionStateChanged(function (change) {
      if (change.newState === $.signalR.connectionState.connected) {

        constellation.registerStateObjectLink("*", "MySensor", "*", "*", function (so) {
          $scope.$apply(function () {
           $scope[so.Name] = so.Value;
          });
        });
      }
    });

    constellation.connect();
  }]);

N’oubliez pas de définir l’adresse de votre Constellation ainsi que la clé d’accès pour vous connecter à votre Constellation lors de l’appel de la méthode « constellation.initializeClient »

Vous obtenez en quelques minutes une page Web permettant d’afficher en temps réel les mesures de température, d’humidité et de luminosité réalisées par votre ESP8266 !

Etape 4 (optionnelle) : créer un package .NET pour exploiter les données du capteur

La page Web réalisée ci-dessus permet d’afficher en temps réel les valeurs de vos StateObjects.

Si maintenant vous souhaitez récupérer la valeur de ces StateObject dans un programme pour réagir en fonction de certaines valeurs (par exemple alerter si T° trop froide ou allumer des lumières si la luminosité est trop faible) ou bien tout simplement enregistrer ces valeurs dans un fichier, une base de données ou un service de cloud, suivez la suite.

Pour cet exemple, réalisons un programme en C#. On part du principe que vous avez installé Visual Studio et le SDK Constellation depuis le « Web Platform Installer ».

Créez alors un nouveau projet de type « Constellation Package Console » :

Dans votre classe, ajoutez simplement des propriétés pour chaque StateObject avec l’attribut « StateObjectLink » pour lier ces propriétés .NET aux StateObjects de votre capteur (servez-vous du snippet « stateobjectlink »).

Par exemple pour inclure le StateObject « Light » dans notre classe C# :

[StateObjectLink("MySensor", "Light")]
public StateObjectNotifier Light { get; set; }

Vous pouvez maintenant afficher sa valeur à tout moment, par exemple :

PackageHost.WriteInfo($"Luminosité {this.Light.Value.LastUpdate} = {this.Light.DynamicValue} lux");

La propriété « Light » de votre classe contiendra toujours la dernière valeur du StateObject connu dans votre Constellation.

Vous pouvez donc manipuler la valeur mesurée par votre ESP8266 dans votre code C# comme une simple propriété .NET de votre code.

Vous pouvez également vous abonner à chaque mise à jour du StateObject pour déclencher une action grâce à l’évènement « ValueChanged » :

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

The post Créer un capteur de température, humidité et luminosité connecté appeared first on Constellation.

Prérequis

• Un Arduino connecté ou un ESP8266
• Un shield relais (ou un relais seul avec une diode, une résistance et un transistor NPN)
• Un serveur Constellation

Etape 1 : le montage

Ici on utilisera un D1 Mini Pro (ESP8266) avec un « Shield » relais tout fait qu’il n’y a plus qu’à déposer sur le « D1 Mini ». Si vous n’avez de shield, vous pouvez utiliser un relais seul que vous piloterez avec un transistor NPN via une sortie de l’ESP8266.

Vous retrouverez sur ce shield un bornier à 3 pôles :

• Le pôle de gauche est « NO » (normalement ouvert)
• Le pole du milieu est le commun
• Le pôle de droite est « NC » (normalement fermé)

Autrement dit, au repos il y a contact entre le 2^ème et 3^ème pole (normalement fermé). Lorsque que vous activez le relais, vous permutez le contact entre la 1^ère et le 2^ème pole.

Si vous voulez piloter une lampe, connectez un des fils entre la source d’énergie et votre lampe sur le pole « commun » et le pole « NO ». Ainsi au repos, votre lampe ne sera pas allumée mais si vous activez votre relais elle le sera.

Attention tout de même si vous manipulez des sources AC 220V et n’oubliez pas que votre relais ne supporte que des charges inférieures à 10A (soit environ 2200W).

Etape 3 : la programmation

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 “MyRelay”.

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", "MyRelay", "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.

Notre relais se pilote par la sortie D1. Commencez donc par configurer cette sortie en ajoutant la ligne suivante dans la méthode « setup() » :

pinMode(D1, OUTPUT);

Ensuite, toujours dans la méthode de démarrage « setup() » et une fois connecté au Wifi, déclarez le MessageCallback suivant :

constellation.registerMessageCallback("SwitchState",
  MessageCallbackDescriptor().setDescription("Set the state of the relay").addParameter<bool>("state", "The state of the relay"),
  [](JsonObject& json) {
      bool state = json["Data"].as<bool>();
      // Changer l'état du relais
      digitalWrite(D1, state ? HIGH : LOW);
      // Mise à jour du StateObject de l'état du relais
      constellation.pushStateObject("State", state);
 });

Nous exposons ici un MessageCallback nommé « SwitchState »  qui prend en paramètre un booléen pour définir l’état du relais (ON ou OFF).

Le code du MC pilotera alors la sortie D1 sur lequel est connecté notre relais et publiera un StateObject « State » avec l’état actuel du relais.

Pour finir, toujours au démarrage, ajoutez cette ligne après la déclaration de votre MC :

constellation.pushStateObject("State", false);

Ainsi au démarrage de l’ESP8266, le relais est forcément sur Off, donc nous actualisation le StateObject « State » sur Constellation avec la valeur « false ».

Et voilà, votre relais connecté est opérationnel !

Vous pouvez connecter sur les pôles NO et commun une charge électrique comme une lampe ou une simple LED, en courant continue ou alternatif (220V par exemple) sans dépasser 10 ampères.

Si vous ne connectez rien sur votre relais, vous pouvez tout de même tester son bon fonctionnement :

• Le relais « claque » lorsqu’il change d’état
• Une petite LED rouge à côté de l’inscription « NC » s’allumera quand le relais est sur « ON »

Lancez le MessageCallback Explorer de la Console Constellation pour tester votre MessageCallback :

Etape 3 : créer une page Web de pilotage du relais

Créons maintenant une page Web pour piloter notre relais. Pour cela créez un fichier HTML sur votre poste avec une structure HTML de base.

Dans les entêtes ajoutez les scripts suivants :

<script type="text/javascript" src="https://code.jquery.com/jquery-2.2.4.min.js"></script>
<script type="text/javascript" src="https://ajax.aspnetcdn.com/ajax/signalr/jquery.signalr-2.2.1.min.js"></script>
<script type="text/javascript" src="https:/cdn.myconstellation.io/js/Constellation-1.8.1.min.js"></script>
<script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/angularjs/1.5.7/angular.min.js"></script>
<script type="text/javascript" src="https://cdn.myconstellation.io/js/ngConstellation-1.8.1.min.js"></script>

Sur la balise <html> ajoutez l’attribut :

ng-app="MyDemoApp"

Et sur la balise <body> ajoutez l’attribut :

ng-controller="MyController"

Ajoutez ensuite le script suivant dans votre page (dans une balise <script>) :

var myDemoApp = angular.module('MyDemoApp', ['ngConstellation']);
myDemoApp.controller('MyController', ['$scope', 'constellationConsumer', function ($scope, constellation) {

      constellation.initializeClient("http://localhost:8088", "clé d'accès ici", "MyRelay Controller");
      constellation.onConnectionStateChanged(function (change) {
          if (change.newState === $.signalR.connectionState.connected) {
              console.log("Je suis connecté !");

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

          }
      });
      constellation.connect();
      $scope.constellation = constellation;
  }]);

N’oubliez pas de définir l’adresse de votre Constellation ainsi que la clé d’accès pour vous connecter à votre Constellation lors de l’appel de la méthode « constellation.initializeClient ».

Enfin, ajoutez sur votre page la valeur du StateObject « State » et un bouton pour envoyer un message au package « MyRelay » afin d’invoquer le MC « SwitchState ».

Par exemple avec quelques classes CSS issues de Bootstrap :

<div class="panel" ng-class="RelayState ? 'panel-danger' : 'panel-default'">
    <div class="panel-heading">
        <h3 class="panel-title">My Relay</h3>
    </div>
    <div class="panel-body">
        <p>Current state : {{ RelayState ? "ON" : "OFF" }}</p>
        <a href="#" class="btn btn-primary" ng-click="constellation.sendMessage({ Scope: 'Package', Args: ['MyRelay'] }, 'SwitchState', !RelayState)">Switch {{ RelayState ? "OFF" : "ON" }}</a>
    </div>
</div>

Vous obtenez en quelques minutes une page Web permettant de piloter en temps réel votre relais avec un retour sur son état courant.

Vous pouvez d’ailleurs ouvrir la page sur plusieurs navigateurs ou sur plusieurs machines et constater que toutes les pages se mettent à jour en temps réel dès que l’état du relais change.

Etape 4 (optionnelle) : Piloter le relais avec un script Powershell

Pour invoquer votre MessageCallback depuis un script Powershell nous allons utilisez l’interface http.

Vous pouvez d’ailleurs afficher le code snippet pour obtenir l’URL depuis le MessageCallback Explorer.

Dans notre cas l’URL sera : http://localhost:8088/rest/consumer/SendMessage?SentinelName=Consumer&PackageName=DemoPowershel&AccessKey=xxxx&scope=Package&args=MyRelay&key=SwitchState&data=true

Comme vous le constatez nous utilisons l’interface « /consumer ». L’argument « sentinelName » doit donc être « Consumer » et le nom du package est en fait un « friendly name » que nous appellerons ici « DemoPowershell ». Vous devez remplacer le « xxxx » par une clé d’accès valide, par exemple la même que celle utilisée par les ESP.

Notre Powershell est donc un « consommateur » et non un « package virtuel ». Il n’y a donc pas besoin de le déclarer dans la configuration de notre Constellation. Un consommateur peut envoyer ou recevoir des messages et consommer des StateObjects mais il ne peut pas écrire de log ni même publier des StateObjects.

Si vous souhaitez utiliser ce script sur une autre machine sur le serveur Constellation, remplacez dans l’URL « localhost » par l’adresse IP ou DNS de votre serveur Constellation.

Pour invoquer une URL en Powershell vous pouvez utiliser la command-let « Invoke-WebRequest ».

Créons alors un script Powershell que nous nommerons « SwitchRelay.ps1 » avec le code suivant :

param (
    [Parameter(Mandatory=$true)][bool]$state
 )
$res = Invoke-WebRequest ("http://localhost:8088//rest/consumer/SendMessage?SentinelName=Consumer&PackageName=DemoPowershell&AccessKey=5863d9e4cbdf522eaa62e0747fceb1c5b249ba13&scope=Package&args=MyRelay&key=SwitchState&data=" + $state.ToString().ToLower())
Write-Host "SwitchState to" $state

Et voilà votre commande Powershell est capable d’invoquer un MessageCallback dans votre Constellation et donc de piloter le relais de votre ESP8266 !

The post Créer un relais connecté appeared first on Constellation.