Projet réalisé par Théo DELOOSE, Clara BOMY, Clément NOUGÉ, Mathieu GABRIEL, Marine DAEL et Thaï-Son DANG.

Introduction

Nous sommes six étudiants en troisième année à l’ISEN Lille. Dans le cadre de notre projet de fin d’année, nous avons conçu une serre connectée dédiée à un usage en intérieur. Celle-ci est équipée d’un système d’éclairage intelligent, d’une pompe d’arrosage automatique et d’un brumisateur intégré afin de garantir la bonne croissance des plantes, rassemblant les conditions nécessaires à leur développement. Pour une plus grande facilité d’utilisation, notre serre est associée à une application mobile simple et ludique permettant de suivre en temps réel les données de l’environnement de la serre et de contrôler celle-ci à distance.

En réalisant ce projet, notre but était de proposer une solution de serre connectée à un prix raisonnable et possédant une interface attrayante pour améliorer l’expérience de l’utilisateur.

De plus nous voulions que la serre puisse être intégrée dans différents systèmes facilement pour que l’utilisateur puisse utiliser les données à sa guise.

Fonctionnement général

Nous avons pensé FriendLeaf comme un système de monitoring et de pilotage. Il propose en effet de gérer automatiquement l’arrosage, l’humidité et la luminosité de la serre, ou bien de les activer manuellement à notre guise. Il synchronise les données récupérées par les différents capteurs grâce à la plateforme Constellation et active, par le biais d’un relais, les actionneurs. Enfin, FriendLeaf alerte l’utilisateur lorsque le réservoir d’eau est vide. Tout est synchronisé en temps réel comme par magie grâce à Constellation.

Nous avons donc ajouté dans la serre les capteurs permettant de relever les informations sur l’humidité de l’air et du sol, sur la température et sur la luminosité.  L’équipement installé comporte aussi une guirlande lumineuse ayant pour but d’éclairer et d’afficher les alertes, une pompe pour le système d’arrosage et un brumisateur permettant d’humidifier l’air.

Matériel utilisé

Pour réaliser notre projet, nous nous sommes servis des composants suivants :

Pour la Serre :

• Serre SOCKER Ikea (12,99€), Ikea
• Bac pour le terreau (1,50€), Jardinerie
• Carte Raspberry Pi 3B (40,80€), Amazon
• Relais 4 canaux supportant jusqu’à 5A et 250V (AC) et 30V (DC) (9,99€), Amazon
• Câbles de connexion
• Boîte de dérivation

Pour les capteurs :

• Humidité et température air : DHT11 (1,31€), Amazon
• Luminosité : TSL2561 (6,95€), Gotronic
• Humidité sol : GT110 (2,40€), Gotronic
• Niveau d’eau : Gravity SEN0205 (10,50€), Gotronic

Pour le brumisateur :

• Un émetteur à ultrasons (9,89€), Amazon
• Une alimentation pour le brumisateur (24V DC, 1A) (25€), Derotronic, Lille
• Un bol

Pour le système d’arrosage :

• Une pompe à eau (5,48€), Amazon
• Une alimentation 12V 600mA (12€), Derotronic, Lille
• Un jerrican (environ 10€)
• Un tuyau (ø7mm -ø10mm), Diall

Pour l’éclairage :

• 2m de guirlandes lumineuses (1m LED et 1m incandescent), Blachère
• Une alimentation pour fil lumière, Blachère
• Colliers de serrage

Conception de la serre

Étape 1 : Préparation de la serre

Dans la serre, nous avons disposé les capteurs, le pot et un bol pour le brumisateur. Nous avons également percé des trous pour pouvoir faire passer tous les capteurs et le tuyau d’arrosage.

Pour ce qui est de la guirlande lumineuse, il nous a fallu percer quelques trous supplémentaires dans les montants de la serre pour y glisser les colliers de serrage.

Étape 2 : Branchement du relais

Afin de pouvoir contrôler les actionneurs, nous avons branché le relais quatre canaux à une carte Raspberry Pi.

Celui-ci est analogue à un interrupteur. Pour chaque canal, une alimentation est nécessaire et chacun d’entre eux peut être piloté individuellement grâces aux différents pins dont dispose le relais. Il faut également prévoir une masse que l’on branche sur le pin “Gnd” du relais.

Par défaut, lorsque les pins d’entrée ne sont pas alimentés, les canaux du relais délivrent la tension d’alimentation correspondante sur la sortie NC (“Normally Closed”) ou sur la sortie NO (“Normally Open”) dans le cas contraire.

Etape 3 : Éclairage de la serre

Pour l’éclairage de notre serre, nous avons percé des trous dans la structure et fixé la guirlande avec des colliers de serrage. Celle-ci doit être alimentée par une tension de 230V (tension secteur) et est composée d’un mètre de LEDs rouge et d’un mètre incandescent jaune.

Elle est connectée au relais par la phase et le neutre, chacun branchés sur un canal différent, afin d’isoler totalement la guirlande du secteur et ainsi éviter tout problème avec le reste des composants.

Etape 4 : Installation du brumisateur

Pour augmenter l’humidité de l’air dans la serre, nous avons installé un brumisateur fonctionnant par émissions d’ultrasons. Il nécessite une alimentation de 24V/1A maximum. On le relie ensuite au relais. La masse est directement connectée à l’adaptateur secteur par le biais d’un domino.

Etape 5 : Installation du système d’arrosage

En ce qui concerne l’arrosage, nous disposons d’une pompe submersible qui nécessite une alimentation de 12V et 400mA. Elle est branchée en sortie à un tuyau percé pour un arrosage homogène. Nous la connectons ensuite à un des canaux du relais.

Pour le réservoir, nous avons récupéré un bidon de vinaigre de 5L sur lequel nous avons fait un trou pour le capteur de niveau d’eau et une ouverture pour le remplir et y faire passer la pompe.

Pour résumer…

Étape 6 : Mise en place des capteurs et paramétrage de la carte Arduino

Nous installons à présent les capteurs d’humidité/température de l’air, d’humidité du sol, de de luminosité et de niveau d’eau. Nous branchons tous ces capteurs aux pins de la Raspberry ou de l’Arduino en faisant attention au fait que :

• Les capteurs d’humidité du sol et de niveau d’eau se branchent sur du 5V.
• Les capteurs d’humidité/température de l’air et de luminosité sont alimentés en 3,3V.

Étape 6.1 : Capteur d’humidité et de température de l’air

Le capteur d’humidité et de température de l’air fournissant des données numériques, nous le relions directement à notre Raspberry Pi comme montré sur le schéma ci-dessous :

Étape 6.2 : Capteurs de luminosité, d’humidité du sol et de niveau d’eau

Ces capteurs fournissant des données analogiques, nous les avons branchés à une carte Arduino nano qui permet de lire ces données, contrairement à la Raspberry. Elle est reliée directement par USB à la Raspberry Pi comme montré ci-après :

Étape 6.3 : Programmation de la carte Arduino

Dans l’IDE Arduino, nous avons donc commencé par programmer la carte.

Nous ajoutons tout d’abord les librairies d’Adafruit pour pouvoir initialiser le capteur de luminosité et régler le temps d’intégration des données. Dans le gestionnaire de bibliothèque (menu Croquis > Inclure une bibliothèque), nous avons installé les librairies suivantes :

• Adafruit Unified Sensor
• Adafruit TSL2561

Au démarrage, dans la méthode “setup()”, nous configurons les pins utilisés. Nous décidons d’utiliser les pins analogiques A0 et A1, respectivement pour le capteur d’humidité du sol et du niveau d’eau et les pins A4 et A5 pour le capteur de luminosité :

void setup(void) 
{
  Serial.begin(9600);
 
  /*Réglage du capteur de luminosité*/
  if(!tsl.begin()) //Initialisation du capteur
  {
    //S'il y a un problème pour détecter le capteur, vérifier votre connexion
    Serial.print("Ooops, pas de capteur détecté... Vérifier votre connexion!");
    while(1);
  }
  
    //Configuration du gain du capteur et du temps d'intégration
    tsl.enableAutoRange(true);          
    tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_13MS);    
 
}

Dans la méthode “loop()”, nous recueillons ensuite les valeurs des capteurs et les faisons afficher sur le Monitor Série en utilisant les commandes analogRead() et Serial.print()  :

void loop(void) 
{  
  /*Pour recevoir une nouvelle donnée par le capteur de luminosité*/ 
  sensors_event_t event;
  tsl.getEvent(&event);
 
  //Lecture des pins analogiques pour les données des capteurs d'humidité du sol et de niveau d'eau
  Hum_value = analogRead(A0);
  Liquid_value=analogRead(A1);
 
  //Affichage des valeurs sur le Moniteur série
  Serial.print(event.light,0);
  Serial.print(',');
  Serial.print(map(Hum_value,0,1024,0,100)); //Le capteur d'humidité renvoie une valeur en pourcentage 
  Serial.print(',');
  Serial.println(map(Liquid_value,0,512,0,1)); //Le capteur de niveau d'eau retourne la valeur 1 quand il est en contact avec l'eau, 0 sinon
  delay(5000); //Retard de 5s pour éviter de surcharger le buffer de la Raspberry 
}

Nous récupèrerons ensuite les données des différents capteurs à l’aide de la carte Raspberry Pi.

La programmation vers Constellation

La programmation vers Constellation est divisée en deux packages : le premier correspond à la récupération des données des capteurs et à l’activation des actionneurs, le second a été créé pour gérer le stockage des données en vue de créer des graphiques sur notre application.

Etape 1 : Package relatif aux capteurs et actionneurs

Etape 1.1 : Acquisition des données des capteurs

Pour récupérer les données des différents capteurs cités précédemment, nous avons utilisé la librairie “Adafruit_DHT” pour Raspberry Pi et la librairie “serial” qui permet de faire le lien entre l’Arduino-Nano et la Raspberry Pi. Ces valeurs vont nous permettre de décider s’il faut activer ou non les actionneurs tels que la pompe, le brumisateur ou les LED.

La fonction ci-après permet de récupérer les valeurs des différents capteurs.

def getCapteur():
    humiditeAir, temperature = Adafruit_DHT.read_retry(11,4)
    lux, humiditeSol, eau = ser.readline()[:-2].split(",")

Nous avons ensuite créé un State Object rassemblant les valeurs d’humidité du sol, d’humidité de l’air, de température et de luminosité ambiante pour pouvoir les publier sur notre Constellation.

Constellation.PushStateObject("Capteurs", {"HumiditeSol": int(self.humiditeSol), "HumiditeAir": int(self.humiditeAir), "Temperature": int(self.temperature), "Luminosite": int(self.lux)}, "CapteursInfos")

Etape 1.2 : Activation et désactivation des différents actionneurs (brumisateur, guirlande lumineuse et pompe à eau)

Comme mentionné précédemment, les actionneurs sont reliés à la Raspberry Pi via un relais quatre canaux. Cela simplifie grandement la programmation : il nous suffit simplement de gérer l’ouverture et la fermeture des relais.

Nous avons donc fait en sorte que chaque actionneur soit associé à son relais grâce à la librairie GPIO de la Raspberry Pi. Ainsi, le code diffère seulement au niveau des numéros des pins utilisés par les actionneurs.

Voici un exemple du code de l’activation et de la désactivation de notre pompe :

GPIO.setmode(GPIO.BOARD)
GPIO.setup(12,GPIO.OUT)
GPIO.output(12,0)

Le pin 12 de la Raspberry est celui relié au relais contrôlant la pompe.

Etape 1.3 : Automatisation des actionneurs

Pour réaliser la fonction d’automatisation, nous nous sommes tout d’abord renseignés sur les conditions propices à la bonne croissance des plantes au niveau de l’humidité du sol et de l’air, de la luminosité et de la température de l’air.

Pour le brumisateur, nous avons choisi de l’activer si l’humidité est inférieure à 35% et de le désactiver si l’humidité remonte au dessus de 37%.

if humiditeAir > 37 and brumisateur:
    DesactiverBrumisateur()
elif humiditeAir < 35 and not brumisateur:
    ActiverBrumisateur()
    time.sleep(1)

Pour la pompe, le fonctionnement est différent. Puisque la diffusion de l’eau dans la terre est plus lente, nous activons la pompe pendant 5s avant de la désactiver pendant 30s pour laisser le temps au capteur de ressentir les changements.

if humiditeSol < 30 and not pompe:
    if self.ticks == 0:
            if self.next_water == 0:
                    ActiverPompe()
            self.next_water = 15
        else:
                    self.next_water -= 1
        elif humiditeSol > 30:
                    self.next_water = 0
    elif pompe:
            self.ticks += 1
               if self.ticks >= 3:
                    DesactiverPompe()
                       self.ticks = 0
time.sleep(1)

Ces différentes fonctions sont exécutées dans des threads séparés pour ne pas que le code soit bloquant.

Maintenant, il ne reste plus qu’à sécuriser notre système d’arrosage via le capteur de niveau d’eau. Connecté à la carte Arduino nano, ce capteur va nous renvoyer 1 s’il y a de l’eau dans le réservoir, 0 sinon.

Les données du capteur de niveau d’eau nous permettent d’arrêter le système d’arrosage lorsque le réservoir est presque vide et d’informer l’utilisateur via un PushBullet et l’allumage des LEDs qu’il faut remplir le réservoir.

Constellation.SendMessage("PushBullet", "PushNote", [ "FriendLead", "Le reservoir d'eau est vide"], Constellation.MessageScope.package)

Étape 2 : Package relatif au stockage des données

Afin d’historiser les valeurs des capteurs stockées dans un des State Objects du premier package, nous en avons créé un autre que l’on a déployé sur le même serveur que Constellation.

Ce package génère une base de données dans un fichier .csv qui est mis à jour toutes les minutes avec les nouvelles données.

Chaque ligne contient la date, l’heure, l’humidité du sol, l’humidité de l’air, la température et la luminosité.

@Constellation.StateObjectLink(package = "FriendLeafCapteurs", name = "Capteurs")
def RecupValue(stateObject):
    humiditeSol = stateObject.Value.HumiditeSol
    humiditeAir = stateObject.Value.HumiditeAir
    temperature = stateObject.Value.Temperature

Nous avons ensuite créé un message callback qui permet de visualiser le fichier CSV dans notre Constellation.

@Constellation.MessageCallback()
def LireBDD():
'''
: return string : La base de données 
'''
    file = open('BDD.csv','r')
    lines = file.readlines()
    return lines

L’interface utilisateur : l’application mobile de monitoring et de pilotage de la serre

Étape 1 : Le noyau de l’application

Pour développer l’application mobile nous nous sommes aidés de Cordova, un Framework permettant de créer des application Android et iOS avec des technologies web.

Nous avons également utilisé jQuery et AngularJS pour faciliter l’interaction entre Javascript et HTML.

De plus, pour gérer certaines fonctionnalités comme le traitement du CSV ou l’affichage des graphiques, nous avons utilisé des librairies externes comme PapaParser et Chartist. Finalement, pour embellir le CSS, nous avons utilisé le Framework SemanticUI qui ressemble en certain points à Bootstrap.

Étape 2 : Connexion à Constellation, State Object et Messages Callback

Pour nous connecter à Constellation avec AngularJS, nous avons utilisé ces lignes de codes :

Constellation.initializeClient(url_port, sha, "FriendLeaf");

Constellation.onConnectionStateChanged(function (change) {
   //suite
});

et une ligne de ce type pour chaque State Object :

Constellation.registerStateObjectLink("*", "FriendLeafCapteurs", "Actionneurs", "*", function (so) {
    //suite
});

Quant aux messages Callback, ils sont envoyés comme suit :

Constellation.sendMessage({ Scope: 'Package', Args: ['FriendLeafCapteurs'] }, 'DesactiverBrumisateur');

Pour que l’application soit utilisable sur n’importe quelle Constellation, nous avons créé un page de configuration où l’utilisateur rentre l’adresse de sa constellation, le port, et des identifiants.

Une fois tout cela rempli, le nom d’utilisateur et le mot de passe sont hachés en SHA1 grâce à une librairie externe et la connexion à Constellation commence.

Lorsque l’application se lance pour la première fois, l’utilisateur est directement redirigé vers cette page pour entrer les informations nécessaires.

Étape 3 : Affichage des données en temps réel

Pour l’affichage des données en temps réel nous avons utilisé des images SVG car elles sont très flexibles et nous voulions réaliser des barres de progression en arc de cercle. Pour les valeurs numériques on affiche un scope AngularJS dans lequel sont stockés les valeurs des capteurs.

Le code JS :

//Stockage des valeurs des capteurs dans la variable capteur
scope.capteurs["humiditeAir"] = so.Value.HumiditeAir;
scope.$apply(); //Applications des modifications du scope

//Pour changer le remplissage de la jauge 
$("#h_air_gauge").css("stroke-dasharray",(so.Value.HumiditeAir*18)/100 + " 18 0");

SVG en HTML :

<svg viewbox="0 0.5 10 8">
    <defs>
    <linearGradient id="linear" x1="0%" y1="0%" x2="100%" y2="0%">
        <stop offset="0%" stop-color="#00ee4f"/>
        <stop offset="66%" stop-color="#eeae00"/>
        <stop offset="100%" stop-color="#ee0000"/>
    </linearGradient>
    </defs>
    <text x="50%" y="50%" id="h_air_value" text-anchor="middle"  alignment-baseline="middle" fill="#00ee4f">
        {{Math.round(capteurs["humiditeAir"])}}%
    </text>
    <path d="M2 8 A 4 4 0 1 1 8 8" fill="none" stroke-width="0.78" stroke="#E8F6FD" />
    <path class="loader" id="h_air_gauge" d="M2 8 A 4 4 0 1 1 8 8" fill="none" stroke-width="0.8" 
stroke="url(#linear)" />
</svg>

Étape 4 : Contrôler sa serre

Nous avons également prévu dans l’application de pouvoir gérer les différents actionneurs de la serre.

Pour gérer le côté automatique du package responsable des capteurs nous avons utilisés des sliders qui lorsqu’activés, vont envoyer un Message Callback comme décrit ci-dessus. On va également suivre l’évolution du State Object indiquant si l’automatisation est activée pour tel ou tel actionneur et ainsi bloqué ou non le bouton d’activation manuel. Car oui, il est également possible d’activer manuellement chaque actionneur grâce à un bouton.

Étape 5 : Les graphiques

Pour ce qui est des graphiques nous avons utilisé une librairie externe que nous avons modifié pour la rendre compatible sur mobile. Cette librairie s’appelle Chartist. Grâce à elle nous avons pu faire de superbes graphiques.

Conclusion

Voilà qui conclut les grandes étapes de la réalisation de FriendLeaf. Comme vous avez pu le voir, la serre remplit complètement son rôle. C’est un projet ludique, simple à réaliser et facilement transposable sur d’autres installations grâce aux State Objects et aux messages Callback. C’est également un bon point de départ pour prendre en main la plateforme Constellation. Nous espérons vraiment qu’il vous a plu et que vous allez réaliser votre propre serre.

Nous tenons également à remercier Léa, le jardin de Théo et les parents de Marine qui nous ont fourni quelques accessoires nécessaires à la serre.

The post FriendLeaf : la serre connectée grâce à Constellation appeared first on Constellation.

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.

Lorsque nous avons acheté notre maison, nous avons entamé de lourds travaux de rénovation ce qui m’a permis de passer du câble multifonction blindé à chaque point de contrôle (interrupteurs) dans l’optique de pouvoir facilement ajouter des fonctionnalités domotique sans avoir recours à des solutions sans fil comme le Z-Wave assez coûteux.

Après l’installation de pas moins d’une dizaine volets électrique dans la maison, il me fallait une solution de pilotage à la fois simple, fiable et surtout économique. De plus cette solution devra être ouverte me permettant de concevoir ma propre interface de contrôle sur tout type de support et de pouvoir facilement ajouter de l’intelligence.

Grace à la plateforme Constellation, un Raspberry Pi et quelques Arduinos, j’ai pu concevoir mon propre système de gestion des volets.

La conception

Concrètement chaque volet dispose de deux phases : une pour la montée et une autre pour la descente.

L’idée est donc de piloter ces deux phases avec des relais. Pour garder le contrôle manuel des volets (c’est-à-dire à partir des interrupteurs encastrés dans le mur), j’ai connecté chaque interrupteur bistable au système pour déclencher les volets (obligatoire pour une certification WAF J).

Pour cela derrière chaque interrupteur des volets, j’ai placé une carte de contrôle avec deux relais 220V et deux entrées. Chaque carte de contrôle est connectée sur un câble multifonction qui arrive à chaque volet. On utilise donc 6 fils : deux pour les entrées des interrupteurs (montée et descente), deux pour la commande des deux relais (montée et descente) et deux pour l’alimentation (5V ou 12V en fonction de vos relais).

Côté budget, comptez moins de 3€ par volet.

L’ensemble des câbles se rejoignent tous jusque dans ma baie réseau au RDC. Chaque volet a donc besoin de deux sorties pour les relais et deux entrées pour l’interrupteur bistable. Avec 10 volets, ça nous donne donc 20 sorties et 20 entrées, beaucoup trop pour un Raspberry !

Toujours dans l’optique de baisser les coûts, j’utilise un réseau d’Arduino Mini Pro acheté moins de 2€ pièce.

Chaque Arduino peut gérer jusqu’à 3 volets. Ils sont tous installés sur une carte et connectés en série sur un bus I2C sur lequel est également connecté un Raspberry qui sera le cerveau des volets, lui-même connecté dans la Constellation.

N’importe quel objet, page Web ou programme connecté dans la Constellation pourra envoyer un ordre à chaque volet. Chaque ordre sera traité par le package Constellation qui tourne sur le Raspberry qui, commandera l’Arduino associé via le bus I2C qui lui-même activera le relais correspondant à l’ordre de montée ou descente du volet cible !

Conception logicielle

Une fois nos volets connectés sur les cartes relais reliés aux Arduinos, il suffit d’activer les sorties pour basculer l’état des relais et donc piloter la montée ou la descente de chacun de nos volets.

Par exemple pour une montée :

digitalWrite(volets[i].relaisMontee, HIGH);
digitalWrite(volets[i].relaisDescente, LOW);

Pour capter un changement d’état sur les interrupteurs bistables, il suffit de lire l’entrée correspondante configurée en pull-up. Si l’entrée change d’état à l’état LOW c’est qu’on vient d’appuyer sur le bouton de montée :

if (digitalRead(volets[i].buttonMontee) == LOW && volets[i].previousSens != 1)
{
  // Demande de montée
}

Pour la communication des Arduino avec la base Raspberry, j’utilise le protocole I2C. Chaque Arduino à son adresse 0x11 pour le 1^er, 0x12 pour le 2^ème, etc.. en esclave sur le bus. Le Raspberry est maître.

Lors du setup, j’attribue l’adresse de mon Arduino et configure des callbacks pour la réception et l’émission :

Wire.begin(SLAVE_ADDRESS);
Wire.onReceive(receiveData);
Wire.onRequest(sendData);

Pour la lecture, dès qu’il y a quelque chose sur le bus, je récupère un Int dont les deux 1^ers bits m’indiquent le n° du volet, suivi d’un bit pour savoir si je dois allumer ou eteindre le volet. En cas d’allumage, le dernier bit permet de connaitre le sens (montée ou descente) :

while(Wire.available()) 
{
    int dataReceived = 0;
    dataReceived = Wire.read();
    rawVal += dataReceived;
}
int rawInt = rawVal.toInt();
int numVolet = bitRead(rawInt,2) & bitRead(rawInt,3)*2;
int allumageVolet = bitRead(rawInt,1);
int sensVolet = bitRead(rawInt,0);
// Envoyer l'ordre sur les sorties du volet correspondant

Pour connaitre l’état des interrupteurs depuis le Raspberry, chaque Arduino écrit sur le bus un Int avec le même format pour indiquer pour chaque volet son état :

Wire.write(/* int représentant l’état du volet */);

Maintenant que je peux piloter l’ensemble de mes volets depuis mon Raspberry, j’utilise la plateforme Constellation pour tout connecter facilement.

Grace au SDK Constellation dans Visual Studio et aux Python Tools for Visual Studio, j’ai créé un package Constellation en Python.

Le package expose des méthodes dans la Constellation pour le contrôle et publie des « StateObjects » sur l’état de chaque volet.

def ActionVoletMessageCallback(data):
    # Action à envoyer à un volet.
    try:
        volet = GetShutter(data["shutterName"].lower())
        actionStr = data["actionShutter"].lower()
     if actionStr == "montee":
            volet.Open()
        elif actionStr == "descente":
            volet.Close()
        else:
            volet.Stop()
    Constellation.WriteInfo("ActionVolet: %s => %s ", (volet.nom, actionStr))

Les methodes Open/Close/Stop écrivent sur le bus I2C avec la commande I2CSet à destination de l’adresse de l’arduino cible, l’entier représentant l’ordre à exécuter :

commande = 'i2cset -y 1 %s 0x%x' % (self.adresse, i)
os.system(commande)

Pour la lecture sur le bus, j’utilise la commande « i2cget ».

f = os.popen('i2cget -y 1 %s' % self.adresse, 'r')
retour = f.read()

Une fois l’entier représentant l’état de chaque volet décrypté, je publie dans la Constellation un StateObject avec toutes les infos :

# Changement, on met à jour le stateobject
 Constellation.PushStateObject(volet.nom, volet.etat, "Shutter",
   {
       "Adresse": volet.adresse,
       "Numero": volet.numero,
       "Statut inversé" : volet.inverseStatut,
       "Commande inversée" : volet.inverseCommande
   })

Une fois mon package développé, je peux directement depuis Visual Studio le publier sur mon serveur et le déployer sur une sentinelle de ma Constellation.

Au préalable j’ai installé une Sentinelle Constellation sur mon Raspberry. Il me suffit ensuite de lancer mon package depuis l’interface Web de contrôle de ma Constellation.

Cette interface me permet également de suivre en temps réel les logs de mes packages :

Aller plus loin avec Constellation

A ce stade l’état de chaque volet de ma maison est publié dans la Constellation et je suis capable de piloter chacun d’entre eux en envoyer un message dans la Constellation à destination de mon package Python.

La suite logique est de créer une interface de pilotage. Pour cela je vais utiliser l’API Constellation pour AngularJS me permettant de créer une application HTML/JS connectée dans la Constellation avec le framework Angular de Google.

Grace à la Constellation, le code Javascript se résume à cela :

app.controller('ShutterAngularController', ['$scope', 'constellation', function ($scope, constellation) {

    constellation.intializeClient("http://constellation.myhome.lan:8088/", "MonAcessKey", "HomeControl");

    var MesVolets = {};
    constellation.onUpdateStateObject(function (message) {
        $scope.$apply(function () {
            $scope.MesVolets[message.Name] = message;
        });
    });

    constellation.onConnectionStateChanged(function (change) {
        if (change.newState === $.signalR.connectionState.connected) {
            constellation.requestSubscribeStateObjects("*", "ShutterController", "*", "*");
        }
    });

    $scope.actionShutter = function (shutter, action) {
        constellation.sendMessage({ Scope: 'Package', Args: ['ShutterController'] }, 'ActionVoletMessageCallback', { 'shutterName': shutter.Name, 'actionShutter': action });
    };

    constellation.connect();
}]);

Dans mon contrôleur, je me connecte à ma Constellation et je m’abonne au StateObject du package « ShutterController ». A chaque réception d’un state object, je l’ajoute dans mon scope Angular. De plus j’ai ajouté une méthode pour envoyer un message de contrôle à mon package Python.

Il ne reste plus qu’à faire une vue HTML en faisant une boucle sur notre variable de scope « MesVolets » :

<div class="list-group-item" ng-repeat="shutter in ShutterController">
    <h3>                        
        {{shutter.Name}}
        <em class="pull-right btn-group" role="group" aria-label="...">
            <button type="button" 
                class="btn btn-default glyphicon glyphicon-chevron-up" 
                ng-class="{ active: shutter.Value==='Montee' }" 
                ng-click='actionShutter(shutter, "montee")'>
                </button>
            <button type="button" 
                class="btn btn-default glyphicon glyphicon-stop" 
                ng-class="{ active: shutter.Value==='Arret' }" 
                ng-click='actionShutter(shutter, "stop")'>
                </button>
            <button type="button" 
                class="btn btn-default glyphicon glyphicon-chevron-down" 
                ng-class="{ active: shutter.Value==='Descente' }" 
                ng-click='actionShutter(shutter, "descente")'>
                </button>
        </em>
    </h3>
</div>

Et voilà comment créer une première interface Web de supervision et de contrôle de l’ensemble des volets à la maison.

Les propriétés des volets étant exposées dans la Constellation, il devient facile d’ajouter de l’intelligence dans la maison. Par exemple, j’ai également un autre Raspberry avec un capteur de luminosité TSL2561 dans ma Constellation ce qui me permet d’ouvrir et fermer les volets en fonction du seuil de luminosité ou encore de fermer automatiquement les volets lorsque je lance un film sur mon XBMC (XBMC/Kodi étant lui-même connecté dans ma Constellation).

Grace à la plateforme Constellation, l’interconnexion des objets devient un jeu d’enfant comme l’orchestration et le déploiement de mes programmes à travers les différents devices de la maison.

Ainsi, moyennant un budget inférieur à 100€, j’ai pu connecter et rendre intelligents mes dix volets.

Lucas Dupuis

The post Connecter ses volets dans la Constellation avec des Arduino et un Raspberry appeared first on Constellation.

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
• 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.

Prérequis

• Un ESP8266 ou un Arduino avec interface réseau
• Un petit écran OLED
• Un serveur Constellation

Etape 1 : le montage

Nous utilisons ici un ESP8266 de type D1 Mini Pro. Nous pouvons alors utiliser un écran OLED en Shield qu’on a juste à « déposer » sur le D1 Mini :

Autre solution, utilisez un écran OLED classique :

Ces deux écrans OLED sont pilotables en I²C. Pour les connexions du 2ème écran, il suffit de connecter les masses (GND) ensemble, la pin « Vcc » de l’écran sur la pin « 3V3 » de la D1 Mini et le « SLK » sur « D2 » et « SDA » sur « D1 ».

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

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", "MyMonitor", "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, installons la librairie « ESP8266 Oled Driver for SSD1306 » pour pouvoir piloter l’écran OLED depuis le gestionnaire de bibliothèque :

Il vous suffit ensuite d’importer cette librairie et déclarer l’objet « display » de cette façon :

#include <Wire.h>
#include "SSD1306.h"
SSD1306  display(0x3c, D1, D2);

Au démarrage de votre programme, dans la méthode « setup() », initialisez votre écran :

display.init();
display.flipScreenVertically();
display.setFont(ArialMT_Plain_10);

Toujours la méthode « setup() » et une fois connecté au Wifi, récupérez le setting « Machine » en prenant soin de recopier la valeur par les lignes :

JsonObject& settings = constellation.getSettings();
static String machine = String(settings["Machine"].asString());

Il ne nous reste plus qu’à enregistrer un ou plusieurs « StateObjectLink » pour récuperer les informations que vous souhaitez suivre.

Dans notre exemple nous allons enregistrer un « StateObjectLink » vers le StateObject « /intelcpu/0/load/0 » du package « HWMonitor » pour la sentinelle définie dans le setting « Machine ».

A chaque mise à jour du StateObject, nous afficherons sa valeur textuellement avec la méthode « drawString » ainsi que dans une barre de progression avec la méthode « drawProgressBar » :

constellation.registerStateObjectLink(machine.c_str(), "HWMonitor", "/intelcpu/0/load/0", [](JsonObject& so) {
    int cpuUsage = so["Value"]["Value"].as<int>();
    // Vider l'écran
    display.clear();
    // Afficher une progressbar
    display.drawProgressBar(0, 32, 120, 10, cpuUsage);
    // Afficher la consommation du CPU
    display.setTextAlignment(TEXT_ALIGN_CENTER);
    display.drawString(64, 15, "CPU = " + String(cpuUsage) + "%");
    // Dessiner sur l'écran OLED
    display.display();
  )});

Demos

Avant de lancer votre code, assurez-vous d’avoir bien déclaré le setting « Machine » avec le nom de la sentinelle sur laquelle est déployé le package « HWMonitor » :

Il ne vous reste plus qu’à téléverser votre programme sur la D1 Mini et observer le résultat.

Et voilà comment en quelque ligne de code vous avez un moniteur temps réel de votre consommation CPU Windows sur un écran OLED piloté par un ESP8266.

Pour aller plus loin

Vous pouvez bien entendu adapter le ou les StateObjects à afficher. Nous avons dans ce tutoriel affiché la consommation CPU mesurée par le package « HWMonitor » mais ce même package met à disposition beaucoup d’autre StateObject : consommation RAM, des disques dur, réseau, température du châssis, consommation énergétique, etc. N’hésitez pas à utiliser le StateObject Explorer pour explorer les StateObjects de ce package.

Il existe aussi plein d’autres packages qui produisent des StateObjects que vous pourrez afficher sur votre écran OLED. Quelques exemples : le package « NetAtmo » pour les mesures sur la T°, humidité, taux de CO², ambiance sonore, pluviomètre et autre ; le package « Nest » sur l’état de votre chauffage, T° ambiante et de consigne ; package « Tesla » pour récupérer en temps réel toutes les données sur votre voiture ; package « DayInfo » pour connaitre les heures du soleil ou la fête du jour ; le package « NetworkTools » où vous pourrez superviser des services TCP ou les temps de réponse de vos sites Web ou encore le package « SNMP » pour pouvoir afficher sur votre écran OLED des informations issues du SNMP, comme par exemple la bande passante de votre routeur.

Bref vous l’aurez compris, la seule limite sera votre imagination !

The post Créer un moniteur connecté pour surveiller vos machines, équipements réseau et autres capteurs appeared first on Constellation.