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.