Le thème de cet après-midi sera 100 % Raspberry Pi & Co en production : serveur, IoT, développement, Docker.

Et à cette occasion, vous retrouverez une nouvelle fois une session dédiée à Constellation spécial Raspberry.

Au menu de cette session :

• Comment déployer une Constellation sur Raspbian en une seule ligne de commande grâce au Web Platform Installer
• Comment joindre des RPi v1, v2, v3 dans Constellation pour y déployer et superviser des packages (programmes) depuis une interface Web centrale
• Comment développer des packages avec Visual Studio ou en ligne de commande avec le « Constellation Package Tools CLI » et les déployer automatiquement sur vos RPi
• Comment vos packages Python sur RPi peuvent interagir avec vos autres systèmes et autres packages Python, C#, objets Arduino ou des ESP8266, des pages Javascript, ou autre
• Comment contrôler un RPi depuis une pages Web ou une application mobile multi-plateforme avec quelques lignes !

Nous verrons également plusieurs applications concrètes déployées pour ma « smarthome » comme : S-Energy, ma solution de supervision des ressources énergique basée sur un Raspberry, S-Opener pour piloter la porte de garage depuis un Raspberry, capteurs luminosité, gestion des volets, etc…

Quand ? 26 octobre à partir de 13h30

Où : à l’école 42 (Paris)

Informations & inscriptions : https://www.programmez.com/content/devcon-4-100-raspberry-pi-co

The post Constellation à la DevCon #4 le 26 octobre à l’école 42 appeared first on Constellation.

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

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

Prérequis

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

Mesurer la luminosité ambiante avec une photorésistance

Le montage

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

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

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

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

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

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

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

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

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

Programmation

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

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

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

MAX_READING = 30000
LIGHT_SENSOR_GPIO = 18
MEASURE_INTERVAL = 10

def OnExit():
    GPIO.cleanup()

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

Constellation.Start(Start)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Mesurer des lux avec un capteur TSL2561

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

Le montage

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

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

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

La programmation

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

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

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

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

Le contenu du script « Lux.py » sera :

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

# Const
EXECUTABLE_FILENAME = "GetTSL2561"

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

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

Constellation.Start(Start)

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

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

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

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

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

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

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

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

Exploitez les données

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

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

Un dashboard Web

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

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

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

Un programme .NET

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

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

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

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

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

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

Historisation avec ElasticSearch / Kibana

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

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

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

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

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

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

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

Stats avec Cacti

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

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

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.