Piloter sa maison ? C’est facile !

3 août 2014

Note : cet article a été initialement publié en deux parties dans le magazine Programmez de Juillet/Août 2012 (n°154) et Septembre 2012 (n°155).

La domotique du latin « domos » (domicile) est l’ensemble des techniques et technologies qui permet de superviser et d’automatiser les services de l’habitat comme l’éclairage, le chauffage, la sécurité mais aussi la consommation de l’habitat, ainsi que les différents services de détente et de loisirs comme la diffusion sonore et vidéo, la téléphonie et l’informatique au sens large.

Ses possibilités permettent aujourd’hui de concevoir des habitats confortables, évolutifs, sûrs, autonomes et économes. Mariée à des technologies d’agents intelligents, la domotique pose les fondations de la maison intelligente et communicante.

Imaginez une maison à qui on parle et qui nous parle, qui enregistre votre émission favorite quand elle sait que vous êtes absent, qui rallume le chauffage quand vous rentrez le soir d’hiver, qui vous accueille avec votre playlist musicale du moment toutes lumières allumées, ou tout simplement vous prévient de prendre votre parapluie lorsque vous sortez et que la météo annonce un orage en prenant le soin d’éteindre les lumières, chauffages, volets, musique et TV à votre place. Rêves ? Non, une réalité !

Pour cela on peut distinguer trois couches permettant de concevoir une maison intelligente : la 1ère est la couche « domotique » qui regroupe toutes les techniques et technologies pour piloter votre maison, comme l’éclairage, le chauffage, volets, prises électriques et mais aussi les différents capteurs pour la sécurité (détecteur de mouvement, d’ouverture, inondation, etc…), la météo et la consommation (électrique, eau, gaz, …). La 2ème couche est la « domotique multimédia », qui rassemble toutes les techniques et technologies pour diffuser et piloter l’audio, la vidéo, la téléphonie et l’informatique dans la maison. Enfin la dernière couche est « l’intelligence », où il est devient possible, grâce à un agent intelligent par exemple, d’humaniser la maison, de la rendre communicante, autonome et intelligente !

Dans cet article nous nous focaliserons uniquement sur les fondations de la maison intelligente, à savoir la couche « domotique » en découvrant les différentes technologies présentes sur le marché et de quelle manière nous pouvons développer avec !

Les technologies domotiques

Les différentes technologies domotiques peuvent être regroupées sous trois catégories en fonction de leur mode de communication :

· Les technologies « filaires »

· Les technologies « sans nouveau fil » (courant porteur)

· Les technologies « sans fil »

Nous pourrions aussi évoquer les technologies infrarouges, comme le SIRCS ou le RC5, mais ces technologies sont très limitées et s’adressent plutôt à l’automatisation des équipements électroniques audiovisuels.

Les technologies filaires

Dans une maison « classique », l’électricité est relativement simple. Elle est distribuée depuis le tableau électrique qui assure la protection des différents circuits et alimente l’ensemble des équipements au moyen de boites de dérivation. Les éclairages sont généralement contrôlés par des interrupteurs, simples dispositifs mécaniques qui « coupent » la phase de la prise/lampe contrôlée. Cette approche ne permet pas de contrôler les équipements et prolifère le 230V dans toute la maison. De plus elle rend difficile l’évolution dans le temps (les câbles étant ancrés dans les murs, le lien entre le contrôleur et l’action peut être difficilement changé !).

Pour résoudre cela des technologies par « bus de commande » sont arrivées il y a plus de quinze ans essentiellement pour les bâtiments industriels et immeubles de bureau. Elles s’implantent aujourd’hui de plus en plus dans les habitats hauts de gamme et commencent à apparaître dans les appartements de standing (dernièrement avec le « Smart Building » construit par Bouygues Telecom et Hager à Aubervilliers). L’idée est de séparer le réseau électrique du bus de commande sur lequel sera connecté les différents éléments de contrôle (interrupteur, thermostat, télécommande, écran tactile, etc…) sur des tensions à faible voltage. Grâce à cela, il nous est possible de contrôler l’ensemble des équipements de la maison depuis n’importe quel type d’interface et nous offre également la possibilité d’associer n’importe quelle commande à une action individuelle, groupée ou générale, et cela à n’importe quel moment (sans modifier le câblage).

Bus de commande

Les technologies les plus répandues étant le KNX et le Lonworks (aux États-Unis). Le KNX est devenu en 2006 un standard normalisé au niveau international et a été choisi par 90% des constructeurs d’équipements électriques en Europe comme Hager, Scheinder Electric ou encore Siemens.

En KNX, le bus de commande est un simple câble de type « paire torsadée » qui parcourt la maison et sur lequel sont connectés en série les éléments de contrôle comme les interrupteurs. L’ensemble des circuits d’éclairage, des volets et prises commandées sont ramenés individuellement au tableau électrique et connectés à des actionneurs KNX (module Rail DIN à installer dans le tableau électrique). Ces actionneurs KNX seront ensuite programmés pour répondre aux ordres émis par les interrupteurs/boutons-poussoirs connectés sur le bus de commande ou par des télécommandes sans fils (avec l’utilisation d’une passerelle radio).

Actionneur KNX

Cette architecture évite la prolifération du 230V dans la maison en scindant le réseau électrique du réseau de commande et permet d’adapter facilement le contrôle des différents circuits en fonction de l’utilisation réelle du logement ou en cas de modification interne. Par exemple, en changeant le lit de place dans une chambre, il est possible de reprogrammer individuellement les interrupteurs et les télécommandes afin de les réaffecter aux modules d’éclairage, de volet, … souhaités. Le protocole KNX supporte aussi le mode de communication sans fil, par courant porteur ou par Ethernet avec l’utilisation de passerelles. Il devient dès lors possible de compléter son installation par des interrupteurs sans fils par exemple. Il est a noté aussi que dans ce genre d’installation, l’intelligence n’est pas centralisée sur un seul équipement : chaque contrôleur connecté sur le bus (comme les interrupteurs) contient son propre microprogramme des ordres à envoyer sur le bus. Le seul « point of failure » du système réside au niveau de l’alimentation du bus de commande, mais il existe bien évidement des systèmes auxiliaires de secours permettant le remplacement de l’alimentation principale.

Modules KNX

Bien qu’à terme ce type d’installation risque de supplanter peu à peu les installations traditionnelles, il est encore aujourd’hui assez couteux à mettre en place et est très difficile à déployer sur un habitat existant. En effet ce type infrastructure demande à câbler individuellement chaque circuit pour le ramener directement sur le tableau électrique (principal ou secondaire) afin de le connecter sur des actionneurs KNX. Cette condition semble très difficile à mettre en place dans des habitats existants, et n’est souvent possible que pour des projets de construction. Le câblage en étoile du réseau de tension et le câblage du bus de commande en série entrainent une dépense importante (on compte environ 1,2Km de câble électrique pour une habitation de 100/150m²) et demandent des ajustements au niveau des plans de construction pour tenir compte de ce câblage important. De plus, le prix de ce genre d’installation est relativement couteux : environ 200€ pour l’alimentation du bus, entre 100 et 500€ pour les actionneurs gérant de 1 à 8 contacts, environs 600 euros pour une passerelle TCP/IP, de 70 à 250€ pour les interrupteurs. Il faut compter entre 5.000 et 20.000€ pour une installation « classique » (on estime en général une installation KNX à 10% du budget global).

À l’image des réseaux filaire Ethernet, la domotique filaire comme le KNX reste un gage de qualité et de fiabilité. Dans un projet de construction et si le budget le permet, la technologie KNX reste le meilleur choix, par contre pour un habitat existant, en maison comme en appartement, cette technologie reste très difficile à utiliser !

Enfin, on pourrait aussi citer les technologies 1-Wire et « web-relay ». La première conçue par Dallas Semiconductor permet de connecter des composants en série, parallèle ou en étoile sur deux fils, souvent utilisée pour des réseaux de capteurs. La seconde, les « cartes web relay » qui fonctionnent par le réseau Ethernet. C’est le cas de l’IPX800 de GCE Electronics (environ 180 euros) qui permet de contrôler 8 sorties sur un module Rail DIN embarquant son propre serveur web pour le contrôle à distance.

Carte "Web relay" 8 sorties

Les technologies « sans nouveaux fils »

Quand il n’est pas possible de passer de nouveaux câbles, une solution consiste à utiliser ceux déjà existants, c’est-à-dire le câblage du réseau de tension. On appelle cela « technologie par courant porteur » où l’on utilise le câblage électrique pour communiquer des informations à une fréquence et tension différentes. Aussi connu sous l’acronyme CPL (courant porteur en ligne), on l’utilise généralement dans les foyers pour mettre en réseau des équipements informatiques facilement sans configuration Wifi ni passage de nouveaux câbles RJ45 : d’où le surnom « sans nouveaux fils » !

Ce genre de technologie demande une bonne qualité de l’installation électrique existante, ce qui dans des vieux bâtiments est rarement le cas. La prolifération de boites de dérivation dans le foyer tend à affaiblir le signal. De plus, de nombreux appareils électroniques peuvent créer d’importantes perturbations sur le réseau électrique ce qui « brouille » la communication entre les équipements. En tête : la machine à laver, le sèche-cheveux, le micro-onde ou encore certaines alimentations des téléphones et ordinateurs. Il faut avant tout auditer son réseau électrique pour déterminer sa qualité, ajouter des filtres sur les équipements qui pourraient perturber le signal et supprimer les sources parasites bien que certaines technologies par courant porteur embarquent directement des filtres anti-bruit.

Parmi les technologies domotiques par courant porteur, on y trouve la solution « In One » de Legrand, le X2D de Delta Dore, le PCLBUS, des passerelles pour le protocole KNX et Lonworks ainsi que le protocole X10.

Le X10 est un excellent moyen de découvrir la domotique très facilement et à moindre frais. Ce protocole a été développé à l’origine par Pico Electronics en 1975. On trouve actuellement différents fabricants de produits X10 comme XDOM, Marmitek, Powerhouse ou Home System. Le protocole X10 supporte aussi le sans fils par transmission radio (433Mhz) grâce à un convertisseur radio/porteuse.

En X10 vous retrouvez trois types d’équipement : les émetteurs, les récepteurs et les contrôleurs.

Les émetteurs permettent d’envoyer des messages X10 sur le réseau comme les télécommandes, certains interrupteurs ou les capteurs (de météo ou de sécurité). En général, les émetteurs fonctionnent par radio.

Detecteur X10 (MS13)

Les récepteurs correspondent à des actionneurs répondant aux ordres X10 dans lequel on retrouve les modules d’Appliance (contact On/Off) et les modules Lampe (qui gère en plus la variation de la tension). Chaque module (émetteur ou récepteur), dispose d’une adresse comportant le code « maison », lettre de A à P, et un code « unité », chiffre de 0 à 16 permettant d’adresser jusqu’à 256 adresses différentes. Chaque adresse est définie physiquement sur chacun des modules, et plusieurs modules peuvent avoir la même adresse (et donc répondre aux mêmes ordres).

Récepteurs X10

Les récepteurs peuvent prendre la forme de module « gigogne », c’est-à-dire qu’ils s’intercalent entre la prise électrique et l’équipement à brancher (ou entre la douille et l’ampoule à viser) ou bien sous forme de module Rail DIN à installer dans le tableau électrique (ce qui rend l’installation plus discrète).

Installation des modules X10

Les contrôleurs permettent d’émettre et de recevoir des messages X10 sur le réseau électrique ou radio. Ils disposent généralement d’une interface USB ou TCP/IP pour être exploiter par un PC, une tablette, etc…

Bien que le X10 soit relativement peu couteux et très simple à mettre en œuvre, il souffre de sérieux inconvénient comme sa fiabilité et sa sécurité !

En effet, tout le monde peut émettre et écouter sur le réseau X10 ! Soit par les ondes soit par le réseau électrique, en branchant un simple contrôleur sur une prise électrique, vous pourrez donner n’importe quel ordre X10 sur le réseau ! Dans un immeuble on recommande d’ailleurs de mettre un filtre juste après l’arrivé EDF pour être sûr qu’aucun ordre émis dans l’appartement à côté ne peut arriver chez vous !

Hormis la sécurité, c’est son degré de fiabilité qui nous pousse à réfléchir quant à son installation à travers toute la maison ! Tout d’abord certaines perturbations générées par les appareils électriques (TV, Hifi, PC, électroménager) brouillent les signaux X10 et l’ordre n’arrive pas à destination ! Ces perturbations électriques peuvent également déclencher des ordres X10 non souhaités ! Il m’est déjà arrivé d’avoir une lampe qui s’éteint ou s’allume toute seule ! Les ordres sont relativement longs à être transmis sur le réseau (50 bits/sec), et comme le protocole ne gère pas le retour d’état (accusé de réception), lorsque l’on donne un ordre (éteindre une lumière par exemple), il faut « croiser les doigts » pourvu que l’ordre soit bien transmit, bien reçu et bien exécuté par le récepteur. Aucune garantie ne sera donnée si ce n’est la vérification visuelle par soi-même (il existe aussi la possibilité d’envoyer au récepteur X10 un message de type « Query » lui demandant de renvoyer un message indiquant son état).

Module X10 sur Rail DIN

Pour obtenir une bonne qualité de service avec le X10, la « best practice » est de privilégier l’usage des modules Rail DIN de manière à centraliser l’ensemble des récepteurs dans le tableau électrique afin de minimiser la distance à parcourir entre le contrôleur et les récepteurs (et éviter l’exposition aux perturbations électriques sur réseau). Mais cela demande comme pour une installation KNX, de câbler en étoile son réseau électrique pour ramener individuellement chaque prises/lampes au tableau. Dans le cas d’un logement existant il est donc impossible à mettre en œuvre sans entamer un lourd chantier de rénovation !

Les technologies « sans fil »

Comme il est difficile d’équiper son habitat avec une technologie filaire (demandant de revoir complètement le câblage) ou que son réseau électrique ne soit pas propice aux technologies par courant portant, la dernière possibilité reste l’utilisation du « sans fil » !

Comme nous l’avons vu, il existe des extensions aux technologies domotiques filaires ou par courant porteur pour fonctionner sans fil. C’est le cas du KNX qui propose une passerelle « KNX radio » permettant d’ajouter des interrupteurs (contrôleurs) sans fil lorsqu’il n’est pas possible de les connecter sur le bus de commande. Il en va de même avec le X10 qui laisse la possibilité de rajouter des équipements sans fil, pratiques pour les détecteurs de sécurité (souvent placés à des endroits où il n’y a pas de prise de courant à proximité). Aussi, les gammes de produits déjà citées, comme celles de Legrand (InOne), Insteon, Lonworks ou encore X2D de Deltadore, proposent des extensions sans fils. Il faut cependant les considérer comme des « extensions » venant étendre un réseau domotique filaires ou CPL, et non comme la possibilité de créer un réseau domotique 100% « sans fils ».

Produits DIO de Chacon

En entrée de gamme, il existe un ensemble de produits domotiques « grand public » que l’on trouve dans les grandes surfaces ou magasins spécialisés. Des packs généralement composés de prises gigognes et télécommandes permettent (pour moins de 30 euros) de télécommander quelques prises, très pratiques pour contrôler les lampes du salon. On y trouve la technologie HomeEasy utilisée notamment par les produits Chacon que l’on retrouve un peu partout en France. Cette technologie monodirectionnelle peut être pilotée « informatiquement parlant » grâce à des émetteurs/récepteurs de trame RF 433Mhz comme avec le RFXCOM (en version USB à 95 euros ou en version LAN pour 200 euros). Le RFXCOM permet de piloter des produits X10, Insteon, sondes Oregon Scientific, etc…

RFXCOM en version USB

Chez Somfy, Velux, Assa Abloy (serrure électronique) ou encore Honeywell, on utilise la technologie IO Homecontrol, plus haut de gamme, avec l’avantage d’être bidirectionnelle. On peut noter aussi l’arrivé en Janvier 2012 de Castorama sur le marché avec la gamme de produit Blyss (projet « liveez Technology »), qui propose une box domotique sans fils (nommé la Blyssbox) et d’un catalogue assez riche de module émetteur et récepteur sans fils.

Depuis 2010, on a pu voir apparaitre en France une technologie prometteuse : EnOcean. Cette société allemande a inventée une technologie de communication sans fil et sans pile ! Celle-ci est généralement utilisée pour les capteurs et émetteurs. Elle capte l’énergie de l’environnement, soit de la lumière (cellule photovoltaïque), soit d’une différence de température ou encore de la pression mécanique sur un interrupteur. Il n’y a donc plus besoin de câble ni de pile ! Il faut compter environ 70 euros pour des interrupteurs EnOcean et environ 500 euros pour la centrale.

Interrupteur EnOcean

La fiabilité reste le principal défi du « sans fil ». En effet comment pouvons-nous être certains que l’ordre arrive bien à sa destination ? Comment fait-on dans un grand logement, avec différentes contraintes (murs porteurs, canalisations, …) qui affaiblissent considérablement le signal ?

Lorsqu’il s’agit d’équiper une seule pièce pour piloter quelques lampes grâce à une télécommande, cela ne pose pas de problème (la proximité entre la télécommande et les lampes limite les problèmes de transmission et si la lampe ne reçoit pas l’ordre, elle ne s’allumera pas. J’aurai donc une confirmation visuelle et dans ce cas, j’appuierai à nouveau sur le bouton de la télécommande). Mais lorsqu’il s’agit d’équiper entièrement son habitat pour contrôler l’ensemble des équipements, il semble primordial d’avoir confiance sur le fait que l’action émise localement ou à distance sera quoiqu’il en soit bien exécutée ! Pour cela il est nécessaire d’utiliser une technologie bidirectionnelle à retour d’état, afin de confirmer au contrôleur et/ou à l’utilisateur que l’ordre a bien été réceptionné et exécuté par l’actionneur cible grâce à l’envoi d’un accusé de réception.

La sécurité peut aussi être une problématique. Par exemple, une télécommande de la marque IDK permettant de piloter jusqu’à 16 prises est sécurisée par la programmation d’un « code maison/unité » entre la télécommande et les prises. Mais sur ce produit, le code n’a que 16 combinaisons possibles ! Autant vous dire qu’il parait très facile de piloter le réseau de votre voisin en essayant toutes les combinaisons de code un à par un (comme avec le X10 d’ailleurs, où il n’y a que 16 codes « maison » possibles, les lettres de A à P !).

Prises télécommandables IDK

Enfin, pour résoudre les problèmes liés à la distance de transmission et contrer les différents obstacles, il est nécessaire d’utiliser des répétiteurs/relais ou routeurs afin de couvrir l’ensemble de l’habitat. Dans cette lignée, il existe deux technologies très intéressantes : le ZigBee et le Z-Wave qui permettent de créer des réseaux maillés. Dans cette topologie certains éléments du réseau (émetteurs ou récepteurs) peuvent se comporter comme des relais et ainsi créer un réseau de maillage. Dans le cas où le contrôleur ne parvient pas à joindre directement le récepteur cible, il peut transmettre l’ordre à d’autres équipements, physiquement plus proche, qui se chargeront de router le message jusqu’à « bon port » en utilisant un ou plusieurs nœuds. À l’image des protocoles de routage sur internet, chaque équipement échange avec ses voisins la liste des équipements qu’ils peuvent joindre directement et ainsi définir une table de routage pour joindre l’ensemble des nœuds du réseau. Lors de l’installation du réseau Z-Wave, il faudra garder à l’esprit cet aspect pour placer judicieusement ces équipements afin de couvrir au mieux son habitat et éviter les « zones d’ombres ».

Réseau maillé

Nous nous arrêterons sur la technologie Z-Wave que nous mettrons en pratique dans la suite de cet article. Pour la partie théorique, le Z-Wave a été développé par une société danoise Zensys, rachetée en 2008 par Sigma Design qui utilise la bande de fréquence de 868,42Mhz pour l’Europe. Bien que propriétaire, une alliance a été créée en 2008 et réunit aujourd’hui plus de 160 fabricants commercialisant des produits Z-Wave. Cela permet de garantir une certaine pérennité du protocole mais aussi un large choix de produits (on compte aujourd’hui plus de 600 produits Z-Wave sur le marché).

Le Z-Wave se définit comme une technologie bidirectionnelle à retour d’état permettant de garantir la bonne exécution des ordres. Très rapide (environ 50ms pour émettre un ordre et obtenir l’accusé de réception) et beaucoup plus sûre par l’utilisation d’un code sur 32 bits (soit plus de 4 milliards de combinaisons possibles) qui bloque tout équipement ne disposant pas du bon code. Enfin, comme décrit précédemment, sa topologie en réseau de maillage permet de couvrir aisément l’ensemble de l’habitat en prenant compte des différentes contraintes physiques.

Un réseau Z-Wave se compose d’un ou plusieurs contrôleurs (clé USB, box Wifi/Ethernet, interrupteurs ou télécommande) « maitre » gérant la sécurité ainsi que le routage. Il est possible de gérer jusqu’à 232 périphériques Z-Wave (au-delà il faudra créer un autre réseau Z-Wave et établir un pont entre les réseaux). Les périphériques peuvent être des actionneurs (prises gigognes, relais encastrables, sirène, module pour volets, ou actionneur de chaudière …) ou des émetteurs (de consommation, de sécurité, météo, interrupteurs, ou télécommandes). Pour lier les émetteurs/récepteurs au réseau Z-Wave (géré par un contrôleur), il faut les appairers en entrant dans le mode « association » sur le contrôleur et en activant le périphérique à ajouter au réseau (appuie sur un bouton ou une séquence de bouton en fonction du produit) dans un rayon de moins de 2 mètres afin de garantir une certaine sécurité quant à l’inclusion de périphériques étrangers ! C’est à ce moment-là que seront recalculées les tables de routage en tenant compte des nouveaux périphériques. C’est pourquoi il est préférable d’associer les périphériques à leurs emplacements définitifs.

ZWave

Contrairement au ZygBee, à l’heure actuelle, le Z-Wave offre un large catalogue de produit et permet d’équiper sa maison pour un budget bien inférieur à certaines technologies filaires tout en garantissant une bonne fiabilité et sécurité (même si rien ne pourrait égaler les technologies filaires, l’utilisation d’un brouilleur à proximité bloquerait l’ensemble du réseau Z-Wave !).

Pour finir, nous citerons les récentes percées d’Orange dans la domotique : il y a quelques mois par l’annonce du support du protocole ZigBee dans la dernière LiveBox Pro qui offrira à terme la possibilité de contrôler des équipements (et arrivera très certainement dans la prochaine LiveBox grand public) mais aussi la dernière solution d’Orange nommée « My Plug », sortie en Mai 2012 qui se compose d’un module avec 2 prises de courants (dont une commandée) et d’une prise d’alimentation USB. Le module dispose d’une carte SIM intégré et donc d’un numéro de téléphone associé, permettant de lui envoyer des SMS pour allumer ou éteindre la prise commandée ou de lui demander son état et sa consommation électrique (le module vous répondra par SMS). Vous pourrez définir jusqu’à 7 numéros de téléphone pour définir les personnes ayant le droit de piloter chaque « MyPlug ». De plus, elle dispose d’une batterie intégrée pour vous avertir par SMS lors de coupure et du rétablissement du courant. Enfin, il existe une fonction localisant un porte-clés ZigBee : en envoyant « qui », le MyPlug peut vous répondre s’il « voit » ou non le porte clé dans son champs ! Cette solution est disponible pour 79,99€ avec un module « MyPlug », un porte-clés et 3 ans de SMS illimités.

MyPlug d'Orange

Solutions retenues

Le choix de la technologie doit s’étudier avec sérieux car il est difficile d’en changer ! Le plus important consiste à choisir en fonction de ses besoins, en privilégiant la facilité d’utilisation : peu importe les différents moyens de contrôle (télécommande, Smartphone, tablette ou même agent intelligent), il est important de conserver les traditionnels interrupteurs qui ne manquerons jamais de piles et seront facilement localisables et utilisables par tous de manière intuitive !

Il faut surtout prendre en compte les contraintes techniques et budgétaires pour choisir sa technologie et envisager l’utilisation de plusieurs technologies pour répondre à besoins différents bien que cela ait tendance à complexifier l’installation.

L’idéal serait l’utilisation du KNX pour son standard et sa fiabilité, mais d’un point de vue technique (impossible de modifier le câblage sans engendrer de lourds travaux) et budgétaire (environ 10% du prix de l’habitat), cela parait difficile à mettre en œuvre.

La 2ème solution retenue peut être aisément déployée à l’ensemble de l’habitat : la technologie Z-Wave que nous mettrons en pratique dans la 3ème partie de cet article.

Néanmoins, pour démarrer à moindres frais dans la domotique, intéressons-nous au développement avec la technologie X10.

Cas pratique n°1 : piloter sa chambre en X10

Pour démarrer il nous faut un contrôleur X10 pour émettre et recevoir des messages X10 sur le réseau électrique et/ou radio. Pour piloter notre réseau depuis un PC, je vous conseille le contrôleur CM15Pro chez Marmitek ou XDom qui propose via une interface USB la possibilité de communiquer en radio ou par courant porteur (disponible pour environ 80 euros). Il existe aussi d’autres contrôleurs comme le CM11 mais il ne gère pas l’interface radio.

 Contrôleur X10 (CM15)

Concernant les récepteurs, il existe une multitude d’équipements possibles : modules de prise de courant, interrupteurs, micromodules à encastrer derrière l’interrupteur existant, modules Rail DIN à installer dans le tableau électrique, etc… Pour notre chambre, nous allons simplement utiliser les modules en prise de courant. Il existe le module AM12 (pour Appliance) qui gère le On/Off, et le module LM12 (pour Lampe) qui supporte en plus la variation de l’intensité de la lampe. Ces deux produits se commercialisent aux environs de 30 euros par module.

Module Lampe X10 (LM12)

Pour l’installation, il suffit de définir l’adresse pour chacun de nos modules en choisissant le code « maison » et le code « unité » et de le connecter sur une prise de courant puis d’y brancher votre équipement à piloter (par exemple une lampe). Pour l’exemple, nous avons installés trois LM12 sur le code maison « A » : A1, A2 et A3 !

Pour piloter tout cela, nous avons le choix entre l’usage d’une télécommande X10, l’utilisation d’une centrale X10 ou dans notre cas, d’un contrôleur X10 pour PC sur lequel il faudra installer une application de contrôle (comme le logiciel d’ActiveHome) ou créer notre propre programme !

Pour développer avec le CM15, rien de plus simple, il suffit d’écrire un programme en .NET en référençant le composant COM d’ActiveHome. Vous le trouverez après avoir installé le SDK ActiveHome dans le dossier « C:\Program Files (x86)\AHSDK\bin », le fichier se nomme « ahscript.dll ».

Il suffit ensuite de créer une instance de classe « ActiveHome ». Vous disposerez sur cette instance de deux membres fondamentaux :

· Une méthode « SendAction » pour envoyer un message X10 sur le réseau

· Un événement « RecvAction » déclenché quand le contrôleur reçoit un message

Ces deux membres comportent dans leurs arguments le type de l’action (SendPLC, QueryPLC, RecvPLC, SendRF ou RecvRF pour définir l’émission, l’interrogation ou la réception, par courant porteur ou radio fréquence), l’adresse du récepteur (A1 à P16), le type de l’ordre (On, Off, Dim, Bright, AllLightOn, AllLightOff) et des paramètres optionnels (comme la valeur du « Dim » ou « Bright » en pourcentage lorsqu’on fait varier l’intensité d’une lampe).

Pour allumer la lampe A1 :

ActiveHome activeHome = new ActiveHome();
activeHome.SendAction("SendPLC", "a1 on", "", "");

Pour la réception, il suffit de s’abonner à l’événement « RecvAction ». Par exemple :

activeHome.RecvAction += new _DIActiveHomeEvents_RecvActionEventHandler(activeHome_RecvAction);
 
private void activeHome_RecvAction(object bszAction, object bszParm1, object bszParm2, object bszParm3, object bszParm4, object bszParm5, object bszReserved)
{ 
        Debug.WriteLine(string.Format("Message recu de l'équipement '{0}' : Action = {1} | Command = {2}", (string)bszParm1, (string)bszAction, (string)bszParm2);
}

J’ai développé en 2008 une API complète pour l’environnement .NET par la définition des objets de base du protocole (décrivant ce qu’est un message, un contrôleur et un device X10 de manière abstraite) et des différents produits X10 : le CM15, les modules AM10, AM12, SW10 mais aussi d’autres équipements comme le détecteur de mouvement MS13, etc… Cette librairie supporte aussi de manière native un mode « proxy » de manière à pouvoir utiliser un contrôleur à distance par l’usage de WCF.

// Utilisation du contrôleur CM15 connecté sur une machine distante
X10ControllerProxy cm15 = new X10ControllerProxy("net.tcp://192.168.0.31:889/CM15.svc");
cm15.Open();
// Ajout des devices
cm15.AddDevice(new ApplianceAM12(X10Address.A1));
cm15.AddDevice(new LampLM12(X10Address.A2));
cm15.AddDevice(new DetectorMS13(X10Address.A3));
cm15.AddDevice(new LampLM12(X10Address.A11));
// Abonnement au changement d'etat
cm15.GetDeviceByAddress<ApplianceAM12>(X10Address.A1).StateUpdated += (object sender, EventArgs e)
    => Console.WriteLine("ApplianceAM12 Update State = " + (sender as ApplianceAM12).State);
cm15.GetDeviceByAddress<LampLM12>(X10Address.A2).StateUpdated += (object sender, EventArgs e)
    => Console.WriteLine("LampLM12 Update State = " + (sender as LampLM12).State);
cm15.GetDeviceByAddress<LampLM12>(X10Address.A3).IntensityUpdated += (object sender, EventArgs e)
    => Console.WriteLine("LampLM12 Update Intensity = " + (sender as LampLM12).Intensity);
cm15.GetDeviceByAddress<DetectorMS13>(X10Address.A11).MotionDetected += (object sender, EventArgs e)
    => Console.WriteLine("DetectorMS13 Motion Detected @ " + (sender as DetectorMS13).LastMotionDetected.ToString());
// Allumage de A1 et A2
cm15.GetDeviceByAddress<ApplianceAM12>(X10Address.A1).TurnON();
cm15.GetDeviceByAddress<LampLM12>(X10Address.A2).TurnON();
// Variation de l’intensité de la lampe A2
cm15.GetDeviceByAddress<LampLM12>(X10Address.A2).SetIntensity(50);

Ainsi, le développement .NET d’une application de contrôle d’un réseau domotique X10 est très facile à mettre en œuvre et peu couteux ! L’idéal pour démarrer ou équiper quelques pièces. Mais comme indiqué plus haut, ses lacunes sur les points de sécurité et surtout de fiabilité (mais aussi de discrétion, ne passant pas le label « WAF ») m’a personnellement freiné quant au déploiement à l’ensemble de l’habitat.

Cas pratique n°2 : piloter sa maison en Z-Wave

La solution que j’ai retenue donc pour mon habitat est le Z-Wave. Sa topologie en réseau de maillage permet de d’obtenir une bonne fiabilité et rapidité dans la transmission des ordres (quasiment instantanée) et sa capacité bidirectionnelle permet d’assurer la bonne exécution des ordres donnés !

Pour commercer, il nous faut un contrôleur « maitre » pour gérer l’ensemble de notre réseau Z-Wave. Nous pouvons utiliser des télécommandes ou interrupteur comme contrôleurs « maitres », des interfaces PC avec l’usage d’une partie logicielle, ou bien opter pour une box domotique embarquant un mini pc généralement à base de Linux y associant la partie hardware et software dans une solution packagée. Dans notre cas, les télécommandes et interrupteurs seront considérés comme des contrôleurs « secondaires » et nous choisirons une solution par box ou PC comme contrôleur « maître ».

Utilisation de contrôleur USB Z-Stick S2 comme contrôleur « maître »

Une 1ère solution consiste à utiliser une interface PC, généralement en USB. C’est le cas notamment du contrôleur Z-Stick S2 d’Aeon Labs commercialisé autour de 65 euros. Ressemblant à une simple clé USB, il comporte une batterie intégrée pour permettre d’inclure ou d’exclure vos périphériques Z-Wave sans avoir à déplacer votre ordinateur ! Pour la partie software, vous pouvez utiliser des logiciels comme HomeSeer, mControl ou encore ControlThink (tous payant). Certains d’entre eux mettent à disposition des API pour contrôler votre réseau Z-Wave depuis vos applications.

Contrôleur Z-Wave (Z-Stick S2)

Autres possibilités, l’achat du SDK directement chez Sigma Design ou développer soi-même son API mais la tâche est beaucoup plus ardue ! La clé Aeon Labs, simple interface COM, est pilotable par un SerialPort en C#.

Dans la pratique, pour contrôler la marche ou l’arrêt d’une simple prise Z-Wave (que nous avons préalablement ajouté à notre réseau Z-Wave), il faut ouvrir le port COM de notre contrôleur Aeon (dans notre exemple connecté sur le port COM7) pour écrire le message suivant :

/*
    0x01, 0x09, 0x00, 0x13, nodeId, 0x03, 0x20, 0x01, state, 0x05, checksum
*/

Le « nodeId » sera l’ID de notre prise Z-Wave à allumer et « state » l’action à exécuter qui sera 0xFF pour allumer la prise ou 0x00 pour l’éteindre. Enfin un checksum sera calculé en faisant un XOR sur les octets du message à l’exception du premier.

SerialPort sp = new SerialPort()
{
    PortName = "COM7",
    BaudRate = 115200,
    Parity = Parity.None,
    DataBits = 8,
    StopBits = StopBits.One,
    Handshake = Handshake.None,
    DtrEnable = true,
    RtsEnable = true,
    NewLine = System.Environment.NewLine
};
sp.Open();
byte nodeId = 0x06; // device ID 6
byte state = 0xFF; // On
byte[] message = new byte[] { 0x01, 0x09, 0x00, 0x13, nodeId, 0x03, 0x20, 0x01, state, 0x05, 0x00 };
message[message.Length - 1] = GenerateChecksum(message);
sp.Write(message, 0, message.Length);
sp.Close();

Chaque envoi de message avec le contrôleur doit être associé à un accusé de réception par l’envoi d’un « ACK » dont le code est « 0x06 ». Ainsi dans notre cas, après l’envoi de notre message pour allumer le nœud n°6, le contrôleur écrira sur le « SerialPort » du COM7 l’octet « 0x06 ». En plus de l’accusé de réception entre le client C# et le contrôleur, le nœud accusera lui aussi réception de l’ordre émis. Votre programme C# recevra donc un 2ème message du contrôleur pour indiquer le résultat de l’exécution du nœud cible qu’il faudra à notre tour « accuser » en émettant un ACK sur le port série !

Il faudra donc créer un thread séparé pour lire les messages arrivant sur les contrôleurs USB et gérer nativement les « ACK » sur le port série. Il faudra également implémenter un à un les différents formats de message propre à chaque périphérique ce qui peut représenter un très long travail. De plus, nous devrons ajouter le support de la découverte des nœuds sur le réseau, la gestion des messages de configuration pour chaque produit Z-Wave, ainsi que toutes les fonctions d’un contrôleur (gestion du pooling des devices, du routing, des copies du réseau entre les contrôleurs, des mise à jours des SUC/SIS, etc..). Les spécifications du protocole Z-Wave se trouvent sur Internet, bien que le document soit classé « confidentiel » et il est aussi possible d’utiliser le site « ZWave Device Library » pour retrouver tous les détails techniques des différents périphériques Z-Wave du marché.

Il existe aussi des projets open-source d’API Z-Wave, notamment le projet Open-ZWave disponible sur Google Code, écrit en C++ pour plateforme Windows, Mac et Linux et dispose en plus d’un wrapper .NET en C++/CLI pour une utilisation dans l’environnement .NET.

Utilisation de la Vera Lite comme contrôleur « maitre »

Pour simplifier son utilisation, nous pouvons nous tourner vers une « box domotique » qui intègre un contrôleur Z-Wave et une interface Web pour piloter et configurer son réseau. Parmi les différents produits sur le marché (eeDomus, les Vera, Home Center, ZiBase, etc…), la Vera Lite de MiCasaVerde offre un bon contrôleur pour 175 euros environ. Cette petite boite (11cm x 9,5cm pour 4,4cm d’épaisseur) dispose d’un connecteur RJ-45, d’une alimentation et d’un port USB. De plus, elle intègre un logement de 4 piles AA pour faciliter les taches d’inclusion et d’exclusion des périphériques Z-Wave et consomme très peu d’électricité (6W).

Contrôleur Vera Lite de MiCasaVerde

Accessible depuis un navigateur Web, l’interface UI5 permettra de configurer son réseau, de contrôler ses périphériques et de créer des scénarios. Elle intègre aussi une « marketplace » pour ajouter de nouvelles fonctionnalités et propose un langage de script basé sur le Lua.

Interface Web UI5 de la Vera Lite

La Vera Lite expose un service web JSON pour piloter son réseau Z-Wave depuis des applications tierces. Par un simple appel HTTP, nous pouvons récupérer dans un objet JSON, la liste des différents périphériques du réseau ainsi que leurs états. Pour lancer un ordre, il suffira d’appeler une URL en précisant dans l’URL l’adresse et l’action à réaliser. Bien plus simple qu’écrire sur un port COM car ici, toute la logique et l’implémentation du protocole du Z-Wave et des périphériques, sont encapsulées par la Vera.

Grâce à cela, il est possible de trouver sur les différents marchés (Apple Store, Google Play ou Marketplace WP7), des applications de pilotage de la Vera permettant le contrôle de son habitat depuis son mobile ou sa tablette, localement ou à distance.

Client sur Windows Phone 7 Client Android

Client pour tablette Android

Contrôler des prises électriques, l’éclairage et le chauffage

Pour les prises électriques, je vous conseille le modèle AN157-6 chez Everspring (environ 35 euros) pour le contrôle de la marche/arrêt. Il existe aussi le modèle AN142-6 (45 euros) pour la fonction variateur. J’utilise aussi le modèle AN158-6 (45 euros) qui remonte au contrôleur la consommation électrique de la prise.

Module AN158-6 avec conso-mètre

Pour l’éclairage, le chauffage ou les volets, je vous recommande les micromodules chez Fibaro à encastrer. Il existe quatre modèles : le FGS-211 (relai 3kW), le FGS-221 (double relai 2×1,5kW), le FGR-221 (pour volet électrique) et le FGD-211 (variateur). Comptez environ 60 euros par module.

Micromodule Z-Wave chez Fibaro

Pour l’éclairage, j’installe derrière mes interrupteurs des modules FGD-211 qui fonctionnent sans le neutre (en général, dans un habitat, un interrupteur va-et-vient ne fait que couper la phase, il n’y a donc pas de neutre qui arrive jusque-là).

Installation d'un FGD-211 pour l'éclairage

Pour le chauffage électrique, j’utilise un double relai (le FGS-221) couplé avec deux diodes de redressement pour contrôler le radiateur par son fil pilote. Le fil pilote permet de commander le mode du radiateur (Arrêt, Hors gel, Eco et Confort) par un courant alternatif. Pour créer ces ordres nous utiliserons des diodes de redressement 1N4007.

Diode de redressement 1N4007

Micromodule FGS221 et ses diodes de redressement

Le module Fibaro et le radiateur sont alimentés par le 230V. La 1ère sortie du module Fibaro est connectée au fil pilote du radiateur par l’intermédiaire d’une diode 1N4007, et la 2ème sortie, elle aussi connectée au fil pilote mais dans le sens inverse.

Installation du FGS221 derrière le chauffage Les micromodules se placent facilement dans les boites d'encastrementSchéma d'installation du FGS221 pour le contrôle du fil pilote

Ainsi, si les deux relais sont sur Off, le radiateur est en mode Confort, si les deux relais sont sur On, c’est le mode Eco. Pour le mode arrêt il faut le relai 1 sur On et le relai 2 sur Off. Enfin, le mode Hors gel est déclenché avec le relai 1 sur Off et le relai 2 sur On.

Pour faciliter l’usage du fil pilote, vous trouverez sur le market de la Vera le module « Pilot wire controller ».

Plugin "Pilot Wire Controller"

Ajouter des capteurs

Pour la température et l’humidité, le modèle ST814 (chez Everspring, env. 50 euros) est un hygromètre-thermomètre radio avec affichage intégré fonctionnant par piles. Pour les conditions extérieures il est possible d’installer depuis le market le plugin Google Weather.

Capteur ST814 chez Everspring

Pour la consommation électrique de l’ensemble du logement, le Home Energy Meter chez Aeon Labs (100 euros) est un module qui utilise des pinces ampèremétriques à installer dans le tableau électrique sur la phase afin de déduire la consommation instantanée et totale (avec une marge d’erreur d’environ 10%).

Pince ampèremétrique connecté sur la phase Module HEM en dehors du tableau pour communiquer au contrôleur la consommation électrique des pinces

Citons aussi les modules de détection d’ouverture de porte (le HSM02 chez Everspring pour 50 euros) ou de mouvement dont certain inclut un capteur de luminosité (chez Express Controls).

Détecteur d'ouverture HSM02

Ajouter des contrôleurs « secondaires »

En plus des interfaces informatiques (web, smartphone, tablette, …) nous pouvons rajouter des télécommandes ou « interrupteurs contrôleurs » pour faciliter l’usage au quotidien.

 Télécommande Minimote chez Aeon Labs

Aeon Labs propose la Minimite (env. 70 euros), petite télécommande qui contrôle jusqu’à 8 scénarios. Et pour ne pas « perdre » le contrôle, il est possible de rajouter ou remplacer nos vieux interrupteurs par des « interrupteurs contrôleurs Z-Wave ». Le ZME 06443 (50 euros) peut s’installer sans boîte d’encastrement et fonctionne avec deux piles ce qui laisse le choix de l’installer sans aucune contrainte. Il permet de déclencher les scénarios par simple clic ou double clic, avec bouton du haut ou du bas.

Interrupteur Z-Wave ouvert Interrupteur Z-Wave installé

Automatiser et surveiller votre maison

La Vera Lite propose une interface pour créer vos scénarios. Les scénarios sont un enchaînement d’actions (ou de scripts Lua), comme par exemple ouvrir un volet, mettre le chauffage, allumer une lampe, etc… Ces scénarios pourront être déclenchés manuellement, par un événement ou de manière planifiée.

Nous voulons par exemple, couper le chauffage quand une fenêtre est ouverte, ou allumer la lumière de l’entrée lorsqu’une présence est détectée et qu’il fait noir.

On peut aussi utiliser les tâches planifiées pour publier l’ensemble des variables de l’habitat sur un service comme Cosm (ex-Pachube) et ainsi suivre l’évolution des différentes informations sur l’utilisation de l’habitat.

local apikey = "xxxxxxxxxxxxxxx"
local base_url = "http://api.cosm.com/v2/feeds/"
local json_datas = {}	
for i,v in pairs(datas) do
	table.insert(json_datas, '{"id":"' .. i .. '", "current_value":"' .. v .. '"}')
end
local json_data_str = '{ "version":"1.0.0","datastreams":[' .. table.concat(json_datas, ',') .. ']}'
local socket = require("socket")
local http = require("socket.http") 
local response_body = {}
local response, status, header = http.request{
	method = "PUT",
	url = base_url .. feed,
	headers = {
		["Content-Type"] = "application/json",
		["Content-Length"] = string.len(json_data_str),
		["X-ApiKey"] = apikey
	},
	source = ltn12.source.string(json_data_str),
	sink = ltn12.sink.table(response_body)
}

Où « datas » serait notre tableau de valeur contenant les différents états de nos périphériques Z-Wave :

local datas = {
	-- EnergyMetering : Watts & KHH
	["HomeEnergyMeter"] =  luup.variable_get("urn:micasaverde-com:serviceId:EnergyMetering1", "Watts", 5),
	["HomeEnergyMeter_KWh"] = uup.variable_get("urn:micasaverde-com:serviceId:EnergyMetering1", "KWH", 5),
	-- SwitchPowerh
	["Prise_TV"] =  luup.variable_get("urn:upnp-org:serviceId:SwitchPower1", "Status", 3),
	["Lampe_Bureau"] = luup.variable_get("urn:upnp-org:serviceId:SwitchPower1", "Status", 9),
	-- PilotWire
	["Chauffage_Salon"] =   luup.variable_get("urn:antor-fr:serviceId:PilotWire1", "Status", 12),
	-- SecuritySensor
	["Porte_Terrasse"] = luup.variable_get("urn:micasaverde-com:serviceId:SecuritySensor1", "Tripped", 11)
	-- TemperatureSensor & HumiditySensor
	["Temperature_Salon"] = luup.variable_get("urn:upnp-org:serviceId:TemperatureSensor1", "CurrentTemperature", 26),
	["Humidite_Salon"] = luup.variable_get("urn:micasaverde-com:serviceId:HumiditySensor1", "CurrentLevel", 28)
}

Le code complet se trouve à l’adresse http://pastebin.com/mHLzmRDB.

 Interface Web de Cosm.com

Interface Web personnalisée pour l'affichage des différents "feeds"

Développer avec la Vera Lite

Pour finir cet article, voyons de quelle manière développer avec une Vera Lite. Il est possible de d’utiliser le Lua, soit pour écrire des scénarios planifiés ou soit pour créer des devices virtuels (comme avec les plugins pour le fil pilote ou la météo Google). Pour contrôler sa Vera Lite depuis sa propre application, nous pouvons utiliser l’API http, en invoquant l’URL http://ip:3480/data_request?id=lu_sdata.

Le service nous retournera un objet JSON qui contiendra la liste et le détail de chaque pièce, la liste des scénarios et bien sûr la liste et le détail des différents équipements Z-Wave de notre réseau. Par exemple, pour le capteur ST817 du salon :

        {
            "name": "Température Salon",
            "altid": "e1",
            "id": 11,
            "category": 17,
            "subcategory": 0,
            "room": 4,
            "parent": 10,
            "temperature": "21",
            "humidity": "66"
        },

Chaque réponse contiendra dans l’objet JSON les champs « loadtime » et « dataversion ». Grâce à cela, vous pourrez lors d’un prochain appel au service, lui définir quelle version vous avez déjà reçu afin d’obtenir seulement les valeurs modifiées.

Pour invoquer des scénarios ou un device en particulier, comme par exemple allumer une prise On/Off (un SwitchPower), il suffit de lancer une requête sur l’URL : http://ip:3480/data_request?id=lu_action&DeviceNum=3&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=1

Pour expérimenter cela, créons une page HTML avec un peu de jQuery pour contrôler notre logement de manière visuelle. Pour modéliser votre habitat, rendez-vous sur HomeStyler.com. Une fois les visuels réalisés, nous les positionnerons sur notre page Web et rajouterons par-dessus des images représentant les lumières allumées ou éteintes.

Côté Javascript, on charge la première fois les informations de la Vera et on vient définir un évènement sur le clic des images pour allumer ou éteindre la lampe.

$(document).ready(function () {
    $.get("Vera.svc/status", function (data) {
        categories = data.categories;
        devices = data.devices;
        // Ajout des controles des Switch lorsque l’on clique sur l’image du device
        $('#controls').children("img").each(function (i) {
            $(this).click(function (event) {
                var deviceType = this.id.split('_');
                if (deviceType[0] == 'light') {
                    if ($(this).attr('alt') == 'Switch Off') {
                        $.get("Vera.svc/setTarget", { id: deviceType[1], deviceType: "SwitchPower1", target: "0" });
                    }
                    else {
                        $.get("Vera.svc/setTarget", { id: deviceType[1], deviceType: "SwitchPower1", target: "1" });
                    }
                }
            });
        });
        // Initial refresh
        refreshState(true);
    }, "json");
});

La fonction “resfreshState” boucle indéfiniment et permet de recevoir de la Vera les changements de valeurs afin de mettre à jour notre interface HTML (états des prises, des lampes ou des chauffages, consommation et valeurs des capteurs de température, d’humidité, de consommation et de sécurité).

var refreshState = function (recursive) {
    $.get("Vera.svc/status", { loadtime: lastRefresh, dataversion: lastVersion },
                       function (data) {
                           $(data.devices).each(function (index) {
                               var categorie = getCategoryNameByDeviceId(this.id);
                               switch (categorie) {
                                   case "Dimmable Light":
                                   case "Switch":
                                        // this.status = 1 si allumé ou 0 si éteint
                                       break;
                                   case "Power Meter":
                                        // this.watts pour la consommation instantanée
                                       break;
                                   case "Temperature Sensor":
                                   case "Humidity Sensor":
                                        // this.temperature et this.humidity
                                   case "Sensor":
                                        // this.tripped = 0 si porte fermé (ou aucune mouvement) ou 1 si ouverte (ou mouvement)
                                   break;
                               }
                               // Display Refresh DateTime
                               lastRefresh = $(data).attr('loadtime');
                               lastVersion = $(data).attr('dataversion');
                               // Refresh in to 2 seconds
                               if (recursive) {
                                   window.setTimeout(function () { refreshState(true); }, 1000);
                               }
                           }, "json");
}

Vue partielle de la page Web représentant l'habitat (salon + terrasse). Les ampoules sont cliquables pour éteindre ou allumer les lampes. De plus l’interface affiche la consommation électrique, les capteurs météo et d’ouverture de la porte de la terrasse.

Conclusion

La domotique est un sujet passionnant qui ouvre beaucoup de possibilités. Ce tour d’horizon des différentes technologies vous donnera matière pour imaginer votre projet en fonction de votre habitat, de vos besoins et de votre budget. Les technologies filaires comme le KNX restent l’un des meilleurs choix mais ses contraintes d’installation et de budget rendent difficile leur démocratisation. Les technologies par courant porteur sont intéressantes mais peuvent souffrir d’un manque de fiabilité sur des réseaux électriques peu récents. Le « sans fils » semble être la solution la plus simple à mettre en place et des technologies comme le ZigBee ou le Z-Wave permettent de répondre à ses principaux défauts (réseau maillé pour une large couverture, retour d’état, sécurité, etc…).

Cependant, peu importe la technologie utilisée, le principal défi reste de privilégier l’usage à la technique. Il faut centrer son projet domotique sur l’objectif souhaité et choisir une ou plusieurs technologies pour y répondre en favorisant la simplicité d’utilisation.

De plus, l’utilisation au sein de vos applications s’avère relativement simple comme présentée à travers cet article. Les technologies de développement habituelles combinées à votre installation domotique vous permettront de réaliser une maison communicante et autonome.

La prochaine étape vers un habitat intelligent reste l’automatisation des équipements multimédia et l’orchestration de toutes ces tâches par une IA ou un agent intelligent, ce qui donnera une dimension supplémentaire à vos projets.

SlightBox V3 : La version “HDMI”

31 juillet 2014

Il y a un an jour pour jour (le 31 Juillet 2013), je publiais sur Facebook une photo “teaser” de ma version 3 de Slightbox (la version “HDMI”) et pourtant par manque de temps je ne l’ai jamais dévoilée !

image

Alors forcément depuis le temps, nombreux sont les projets qui pullulent sur Internet reprenant le même principe à l’image de Light Berry.

Mieux vaut tard que jamais et avec mes excuses pour toutes les personnes qui m’ont souvent relancées pour publier cet article, voici la présentation de ma dernière version de Slightbox, la V3 Sourire

Retour sur SlightBox

Pour ceux qui ne connaissent pas mon projet, SlightBox est un système type Ambilight permettant de produire des effets lumineux derrière votre écran en fonction de la vidéo qui vous visionnez !

Quand j’ai démarré ce projet, c’était en Février 2013, je voulais une solution fonctionnant avec n’importe quel périphérique HDMI mais devant l’ampleur de la tache j’ai décidé de procéder étape par étape, prototype par prototype !

Ainsi les deux premières versions ne sont compatibles qu’avec un PC. Le principe est simple : un logiciel Windows calcule les couleurs moyennes de zone de votre écran et pilote des bandes de LEDs. Le 1er prototype fut développé avec des modules .NET Gadgeteer et la version 2, plus industrielle, avec une puce USB/SPI (une MPC2210).

Pour en savoir plus :

Le résultat du système en vidéo :

 

La promesse HDMI : Le POC

Comme voulu, l’idée finale de Slight était de pouvoir fonctionner avec n’importe quelle source vidéo et pas seulement avec un PC. Pour cela il fallait s’interfacer en HDMI; l’idéal étant de faire une sorte de proxy/passerelle HDMI pour l’analyse du flux vidéo.

Il y a très longtemps sur ce blog, en Février 2006 (déjà 8 ans déjà !!!), je vous parlais du HDCP (lire ici), le système cryptographique visant à crypter les flux HDMI pour lutter contre les copies. Bien que depuis 2010, les fameuses MasterKey ont été dévoilées mettant à mal ce système, il est quasiment impossible de décoder en temps réel un flux HDMI pour analyser le flux vidéo, surtout avec de petit système embarqué comme le Raspberry.

Les 1eres versions de Slight m’ont permis de comprendre comment piloter des bandes de LED et comment analyser les frames d’une vidéo pour produire de beaux effets lumineux. Dans ces 2 versions la source n’est autre que des captures d’écran réalisées avec DirectX. Dans cette version HDMI, il me fallait récupérer des captures d’écran du flux HDMI tout en contournant les protections HDCP.

Je me suis d’abord tourner vers des systèmes d’acquisition HDMI tel que Elgato, le Diamond GC1000, Roxio, Hauppage, etc… Mais ces produits ne peuvent décrypter les flux protégés HDCP. Sinon il y a le HDfury mais très cher pour un prototype, ou le très prometteur NeTV qui, avec le firmware “HDMI stripper” permettait de supprimer la protection HDCP. Mais ces systèmes sont onéreux et difficilement intégrable !

 

C’est quelques jours plus tard que la réponse me fut inspirée par mon père : le Analog Hole ! (lire : le trou analogique).

En effet, un flux HD sur HDMI peut être crypté en HDCP ou non. Si c’est le cas, impossible d’exploiter son contenu si on n’a pas une clé de décryptage ! De plus pour un système Ambilight, un flux HD serait trop couteux en termes de performance !

L’idée est donc de ”downgrader” le flux HDMI en un flux analogique (en S-Video par exemple) permettant d’une part de faire sauter la protection HDCP et d’autre part de baisser la résolution de l’image pour faciliter le traitement. C’est ce qu’on appelle le trou analogique !

Après une étude de marché mon choix s’est porté sur le “Ligawo ® HDMI Composite / S-Vidéo” supportant les flux cryptés HDCP (environ 60€) :

Bien entendu, pour rendre le système transparent, nous utiliserons un splitter HDMI permettant de dupliquer le flux HDMI de votre source (Xbox, PS3, Freebox, etc..) en deux flux : un flux pour votre TV et un autre pour la SlightBox. Pour cette pièce mon choix s’est porté sur le “Neet® – Répartiteur HDMI 2 ports 1×2 (1 entrée, 2 sorties) – 1080p Full HD – Amplificateur actif” supportant les flux HDCP/1080p (environ 30€) :

Une fois notre signal vidéo analogique capturé, une simple clé d’acquisition USB/SVideo fera l’affaire pour pouvoir exploiter l’image depuis un système informatique tel qu’un Raspberry. Pour cela j’ai utilisé la clé EasyCap DC60 achetée il y a quelques années sur un site chinois pour moins de 10€. Sur ce point plusieurs copies chinoises existent avec différentes puces (voir http://linuxtv.org/wiki/index.php/Easycap). La STK1160 fonctionne parfaitement sur RPi/Linux. J’ai également testé une clé avec la puce Somagic (SM-USB 007) mais sans succès et je n’ai aucune idée de la compatibilité des Empia ou UTV. Donc essayez de trouver des clés Easycap DC60 équipées de la puce STK1160.

 

Enfin le cœur du système sera basé sur un Rapsberry Pi que l’on ne présente plus :

Mon schéma du prototype final :

image

Les 1er tests ont été réalisé avec un PS3 qui crypte la sortie HDMI en HDCP et offre donc un bon device de test ! On retrouve le splitter HDM NEET, le convertisseur HDMI/SVideo, la carte d’acquisition EasyCAP, le Raspberry et un écran HD LED HD44780 :

WP_003581WP_003554

Côté logiciel, Slight est écrit en Python et utilise la librairie OpenCV pour l’analyse de l’image.

Au démarrage du service, l’initialise mon device SPI utilisé pour piloter les LEDs et  OpenCV sur le device /dev/video0 pour l’analyse du flux vidéo de la carte EasyCAP.

Enfin, pour sélectionner la bonne source vidéo d’EasyCap (disposant d’une entrée SVideo et composite) ainsi que le format de l’image (SECAM), j’utilise V4l2 (Video For Linux 2) pour paramétrer la source s’acquisition vidéo :

1
2
3
4
5
6
7
8
9
print "Initializing SPI device .."
dev       = "/dev/spidev0.0"
spidev    = file(dev,"wb")
print "Initializing video capture from /dev/video0 .."
capture = cv.CaptureFromCAM(0)
cv.SetCaptureProperty(capture,cv.CV_CAP_PROP_FRAME_WIDTH, 720)
cv.SetCaptureProperty(capture,cv.CV_CAP_PROP_FRAME_HEIGHT, 576)
print"Configuring video capture (V4L2) ..."
os.system("v4l2-ctl -d /dev/video0 -i 5 -s 4 --set-fmt-video=width=720,height=576,pixelformat=4")

Le programme Python boucle ensuite à l’infini pour capturer l’image du flux vidéo et l’analyse pour piloter les LEDs avec le port SPI

OpenCV permet de capturer l’image avec la fonction “QueryFrame()” et analyse ensuite les pixels de la capture avec la fonction “Get2D”. Il ne reste plus alors qu’à porter l’algorithme C# développé pour SLightBox V1/V2 en sur cette version Python.

En simplifiant, voici la boucle principale :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
while True:
   # Capture frame
   frame = cv.QueryFrame(capture)
   width = frame.width
   height = frame.height
   # Init data array
   data = bytearray(NUM_OF_LEDS * 3 + 1) 
  for x in range(NUM_OF_LEDS):
      i = x * 3
      data[i + 0] = MASK
      data[i + 1] = MASK
      data[i + 2] = MASK
   # Process zones
   for z in range(NUM_OF_ZONES):
      avg_pixel = CalculateAvgColorOfZone(z, frame)
      i = LEDS_ON_START * 3 + (3 * (NUM_OF_ZONES - 1))
      data[i + 0]  = gamma[int(avg_pixel[1])] # G
      data[i + 1]  = gamma[int(avg_pixel[2])] # R
      data[i + 2]  = gamma[int(avg_pixel[0])] # B
   # Write data on SPI port
      spidev.write(data)
      spidev.flush()
      time.sleep(0.001)

 

WP_003550

Proof of Concept validé ! Ne reste plus qu’à packager cette usine à gaz Sourire

WP_003582

 

Le Packaging

Pour faire de ce POC un véritable produit autonome, j’ai sélectionné un rack 1U 19pouces vendu une 20aine d’euro chez Farnell ou Selectronic :

WP_003587

Ce rack en ABS facilite l’usinage :

WP_003615

On y trouve :

  • 3 interrupteurs en façade ainsi qu’une fenêtre pour l’écran LCD et un petit trou pour le capteur IR
  • A l’arrière, les deux ports HDMI (In et Out), une embase RJ45 et l’arrivée du 220V

WP_003618

L’idée étant d’avoir l’alimentation embarquée dans la “box” (ci-dessous matérialisée en papier pour avoir l’idée de la taille Clignement d'œil).

En façade trois interrupteurs : un Master pour l’arrivée du 220V (avec LED témoin) et deux autres 5V pour le RPi et le convertisseur HDMI :

WP_003632

Un récepteur IR 38kHz pour le pilotage de Slighbox par votre télécommande comme on le verra plus tard :

WP_003639WP_003640WP_003642

 

Quelques photos de l’assemblage :

WP_003644WP_003750WP_003676WP_003779

WP_003757WP_003974

J’ai également ajouté des radiateurs (heatsinks) sur le splitter HDMI, le convertisseur HDMI et sur le Raspberry pour faciliter la dissipation de la chaleur.

WP_003799WP_003977

WP_003980WP_003981WP_003982

 

Version finale :

 

WP_003683WP_003684

Les inscriptions en façade et sur l’arrière ont été réalisé avec des “Lettres Transfert” de marque SENO.

 

Les fonctionnalités

Comme vous avez pu le voir dans les photos ci-dessus, cette Slighbox renferme une alimentation 220v vers 5V en 10A avec un Raspberry comme cœur du système, une clé de capture SVideo EasyCAP, un splitter HDMI NEET, un convertisseur HDMI/Svideo Ligawo, un écran LCD HD44780 des embases 220v/RJ45/HDMI et quelques interrupteurs.

Un système Ambilight pour toutes vos sources HDMI

Au démarrage du système (basée sur Raspbian), le service “Slight” initialise la capture via V4L2 et OpenCV comme montré lors du POC et pilote les LEDs en fonction du flux vidéo HDMI. Le fameux MVP du produit  Clignement d'œil

Le pilotage des LED LPD8806 se fait par le port SPI en utilisant les GPIO 10 (sortie MOSI) et 11 (Clock). Le Raspberry est directement alimenté en 5V sur les GPIO 2 (5V) et 6 pour le Ground.

A noter qu’il vous faudra dé-commenter la ligne “blacklist spi-bcm2708” dans le fichier /etc/modprobe.d/raspi-blacklist.conf de façon à activer le port SPI sur votre Raspberry.

L’écran LCD

Le programme reporte son statut et performance (notamment le nombre de FPS) directement sur l’écran LCD en façade :

WP_003978

C’est un écran LCD HD44780. J’utilise les GPIO 17/21/22/23/24 et 25 pour l’affichage :

image

Dans sa version finale, SLightbox utilise un écran RGB permettant de choisir vous-même la couleur de l’écran en façade. De plus j’ai ajouté le contrôle du contraste et de la luminosité directement dans le code.

Pour cela, j’ai fabriqué un circuit de contrôle par PWM permettant de gérer le contraste, la luminosité et la couleur (RGB) de l’écran :

WP_003832 WP_003931

Enfin, pour stabiliser le signal PWM sur Raspberry, j’ai utilisé pi-blaster recompilé de façon à générer un signal PWM seulement sur les GPIO de la socket P5 (Gpio 28/29/30 et 31 car par défaut, il utilise toutes les sorties).

WP_003943WP_003982

La (slight) box connectée

A l’arrière vous avez aussi remarqué le port RJ45 permettant de rendre la SlighBox “connectée”. Elle expose via Flask une interface responsive permettant de piloter la SlightBox depuis votre smartphone, tablette ou simple ordinateur.

WP_003679

Vous avez ainsi la possibilité de piloter la couleur des LEDs derrière votre écran sans nécessairement avoir votre TV allumée.

P1140783

De plus, l’interface Web permet de configurer votre Slightbox plus facilement :

image

La télécommande infrarouge

Equipée d’un récepteur IR 38kHz, la Slightbox est capable d’apprendre de vos télécommandes. Vous pouvez ainsi utiliser des touches inutiles de vos télécommandes pour piloter votre Slightbox : la mettre en route, la passer en mode couleur, etc…

Le récepteur est alimenté par la sortie 3,3V du Raspberry (fils rouge & noir) et l’entrée (fil gris) est connectée sur la GPIO 4.

WP_003639

C’est toujours au travers l’interface Web de la Slightbox que vous pouvez configurer tout cela afin d’associer des codes IR à des actions de la Slightbox. Techniquement, j’utilise LIRC pour l’interprétation des signaux IR par le récepteur.

image

Le “soft-hard-reboot” des équipements

A l’utilisation, il se peut que le signal vidéo soit perdu. En général à cause du splitter HDMI et/ou du convertisseur HDMI/SVideo qui « plante » ! Ne reste qu’une seule solution : le hard-reboot du périphérique.

Pour automatiser cette tache, j’ai fabriqué une petite carte avec deux relais permettant de contrôler l’alimentation de ces deux équipements depuis le code sur le Raspberry. L’interface Web de pilotage de la SLightBox offre donc la possibilité de faire un “hard-reboot” du splitter et/ou du convertisseur Sourire

 WP_003959 WP_003962WP_003972

image

 

Conclusion

Et voilà, après un an dans les cartons, je publie enfin cet article sur ma dernière version du système Slightbox. Je l’ai ressorti et réinstallé à la maison après avoir déménagé fin 2013/début 2014 (ce qui explique la latence dans la publication de mes projets Sourire).

La Slightbox V3 traite environ 7 à 10 frames par seconde ce qui est convenable pour produire un bel effet et fonctionne avec mes différentes sources HDMI (Chromecast, Intel NUC, Numéricâble,  etc …)

Pour résumer, le schéma de la bête :

schema

Vous savez maintenant comment monter votre propre SlightBox et si vous avez besoin de quoi que ce soit, n’hésitez pas à utiliser les commentaires Sourire

Pour plus de photos sur le montage de la Slightbox V3, consulter l’album photo sur Facebook : https://www.facebook.com/slightbox

Longue vive à SlightBox,

Geek is in da House : retrouvez-moi en conférence aux Microsoft TechDays 2014 le 11, 12 et 13 février

9 février 2014

logo_mstechdays

L’évènement le plus reconnu par les professionnels du numérique en Europe vous ouvre ses portes les 11, 12 et 13 février 2014 au Palais des Congrès de Paris.

Avec 18 000 visiteurs, les TechDays, ce sont trois jours dédiés aux nouvelles technologies et aux enjeux de la transformation numérique.

En quelques mots :

  • 1 Keynote dédié aux développeurs le mardi 11 février
  • 1 Keynote dédié aux professionnels de l’IT le mercredi 12 février
  • 1 Keynote dédié aux décideurs IT et décideurs métiers autour de l’innovation le jeudi 13 février
  • Plus de 300 sessions
  • Un salon d’exposition de 5500m² avec près de 140 exposants spécialisés
  • Une TechDays TV, chaîne de télévision sur Internet, pour suivre l’essentiel des 3 jours de l’événement

A cette occasion retrouvez-moi en conférence aux côtés de 3 Microsoftees (et non des moindres) : David Catuhe, Stanislas Quastana et Laurent Ellerbach ce mercredi 12 février de 17h45 à 18h45 pour la mythique “Geek is in da House” !

Cette année le geek est toujours dans la maison avec un gros sujet autour de la domotique et quelques surprises dont un retour sur une expérience ésotérique pour les geeks. Encore et toujours du WAF, du backup d’Internet et de la geekerie de qualité française ! Inscrivez-vous le plus rapidement possible car l’année dernière nous avons dû refuser du monde !!!

Fiche de la session : http://www.microsoft.com/france/mstechdays/programmes/2014/fiche-session.aspx?ID=23b47a33-e0a4-45be-848d-607ed0a13a8b

Vous l’aurez compris : beaucoup de domotique cette année et des projets bien geek, du WAF, du fun, et des surprises à gagner !!

Pour suivre la session :

  • Retrouvez-nous au Palais des Congrès de Paris. Par ici les inscriptions, mais attention venez tôt pour avoir de la place Sourire
  • Retrouvez la session rediffusée en direct sur la TechDays TV

A mercredi Clignement d'œil

SlightBox V2 – La version “mini”

9 février 2014

Après un premier prototype d’une solution « Ambilight » maison développée avec des modules .NET Gadgeteer, la “SlightBox V2” est une version miniaturisée et beaucoup moins chère.

Rappel des épisodes précédents :

Pour rappel (voir l’article sur le fonctionnement de la V1), la SlightBox V1 est une box développée avec les modules .NET Gadgeteer uniquement dans le but servir d’interface USB/SPI pour le pilotage des bandes de leds LDP8806. Pour rendre la solution plus compacte et moins onéreuse,  nous allons utiliser une puce MCP2210 de Microchip qui n’est ni plus ni moins qu’une interface USB/SPI en une seule puce  !!

Plusieurs sociétés proposent des modules prêt-à-l’emploi équipés de cette puce. Pour ma part, j’ai sélectionné le produit de Embedded Adventures, le “MCP2210 USB2SPI Module” vendu 15.30$ (hors frais de port) et livré avec une API .NET.

MOD-1013_1_600

Il ne vous faudra plus qu’une petite boite, un connecteur DC pour l’alimentation et un connecteur JST pour y connecter la bande de LED LDP8806.

Pour rappel, nous utiliserons la sortie MOSI pour les “Datas” (équivalent de la PIN 7 sur une socket “S” Gadgeteer), le “SCK” pour l’horloge (équivalent de la PIN 9) et le “GND” pour le ground.

WP_003714WP_003732

WP_003746

A la différence de la SlightBox V1 j’ai supprimé l’interrupteur et la LED témoin de l’alimentation.

WP_003740WP_003741

La SlightBox V1 (à gauche) vs la SlightBox V2 (à droite)

Côté software, la logique reste exactement la même ! La seule différence est dans la façon dont le logiciel va envoyer les données à la bande de LED :

  • Avec la SlightBox V1, c’est la box “Gagdeteer” qui fait office d’interface. Nous utilisons le module “Serial USB” qui est reconnu comme un port COM virtuel au niveau du Windows. Le programme Windows “Slight” envoie donc les données sur le port COM virtuel de la SlightBox qui seront ensuite retranscrits par le programme Gadgeteer sur la sortie “SPI” via le module “Extender”.
  • Avec la SlightBox V2, c’est la puce MCP2210 qui fait office d’interface. Il faut alors utiliser l’API mis à disposition par le fabricant pour pouvoir envoyer nos données !

Pour simplifier le développement côté Windows, nous utiliserons une simple interface pour décrire une « SlightBox » :

1
2
3
4
5
6
7
8
namespace SLight.Devices
{
    public interface ISlightBox : IDisposable
    {
        void Initialize();
        void WriteDatas(byte[] datas);
    }
}

L’implémentation de la SlightBox V2 utilisera alors l’API de la puce MCP2210 pour envoyer les données sur le port SPI à notre bande de leds via la  fonction « TxferSpiData »  :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
namespace SLight.Devices
{
    public class SlightBoxMCP2210 : ISlightBox
    {
        private const int LATCH_BITS = 4;
        private const int SPI_BIT_RATE = 16000;
 
        private const uint MCP2210_VID = 0x04D8;   // VID for Microchip Technology Inc.
        private const uint MCP2210_PID = 0x00DE;   // PID for MCP2210
 
        private bool isConnected = false;
        private DevIO usbDevice = null;
 
        public void Initialize()
        {
            this.usbDevice = new DevIO(MCP2210_VID, MCP2210_PID);
            this.isConnected = this.usbDevice.Settings.GetConnectionStatus();
            if (this.isConnected)
            {
                this.usbDevice.Settings.SetSpiBitRate(DllConstants.CURRENT_SETTINGS_ONLY, SPI_BIT_RATE);
                Console.WriteLine("Connected and ready to use !");
            }
            else
            {
                MessageBox.Show("SlightBox MCP2210 not connected !");
                this.Initialize();
            }
        }
 
        public void WriteDatas(byte[] datas)
        {
            byte[] dataRead = new byte[datas.Length + LATCH_BITS];
            byte[] datasToSend = new byte[datas.Length + LATCH_BITS];
            Array.Copy(datas, 0, datasToSend, LATCH_BITS, datas.Length);
            this.usbDevice.Settings.SetSpiTxferSize(DllConstants.CURRENT_SETTINGS_ONLY, (ushort)datasToSend.Length);
            this.usbDevice.Functions.TxferSpiData(datasToSend, dataRead);
        }
 
        public void Dispose()
        {
        }
    }
}

Et voilà en quelques lignes et quelques soudures comment minuaturiser le concept “Slight”.  Côté performance, c’est exactement la même chose qu’avec la V1.

Et si vous ne l’avez toujours pas vu, voici le résultat :

Développé initialement pour “Slight” (ma solution “Ambilight” maison), la SlightBox et plus particulièrement la SlightBox V2 en raison de sa taille réduite, peut servir dans un tas d’application où nous avons besoin de piloter des bandes de LED.

Retrouvez plus d’informations et photos sur la page Facebook SlightBox.

SlightBox V1 : un système « Ambilight » avec C# et Gadgeteer

9 février 2014

Cet article a été initialement publié dans le magazine Programmez! n°165 paru en Juillet/Aout 2013.

Inventée en 2002 par Phillips, la technologie Ambilight consiste à générer des effets lumineux autour de l’écran en fonction du contenu vidéo. Nous allons découvrir dans cet article comment développer notre propre système « Ambilight » en utilisant des modules « .NET Gadgeteer » et un peu de C#. Préparez Visual Studio, une perceuse et un fer à souder !

Principe de fonctionnement

Il n’est pas très complexe de développer un système « Ambilight » performant. Dans cette première version, le prototype « SLightBox » est conçu pour fonctionner avec Windows. Cela vous permettra de profiter de ce système sur vos ordinateurs ou media-centers quel que soit le contenu vidéo (photo, vidéo, jeu ou toute autre application ou média).

Pour réaliser un prototype rapide du concept, les modules .NET Gadgeteer basés sur le .NET Microframework offrent une plateforme de développement très facile à utiliser pour les développeurs.

Comme cette première solution se base sur l’utilisation d’un PC, l’analyse du contenu vidéo sera relativement simple à entreprendre : capturer l’écran afin de récupérer l’ensemble des pixels affichés !

Pour obtenir une expérience visuelle immersive nous avons besoin de dispositifs lumineux derrière l’écran longeant chacun des côtés. Pour que l’effet soit optimal, l’écran devra être placé à plus ou moins 30 cm d’un mur, si possible de couleur claire (idéalement blanc). De plus ces dispositifs lumineux, comme des LEDs par exemple, devront être contrôlables individuellement.

Une fois la capture de l’écran réalisée, le logiciel calculera la moyenne des couleurs pour chaque zone afin d’envoyer cette couleur à sa LED associée, située derrière l’écran (on établit qu’une zone est associée à une LED uniquement). Cette opération doit avoir lieu plus de 10 fois par seconde pour rester fluide et réactive par rapport au contenu vidéo.

Le hardware

Les LEDs

La solution la plus adaptée au besoin sera d’utiliser des bandes de LEDs multicolores. Ces bandes de LED offrent la possibilité de les sectionner à certains endroits de la bande (en général par pas de 3 à 10 cm) permettant ainsi une plus grande souplesse d’utilisation. Il existe cependant deux types de bandes LEDs multicolores : les analogiques et les digitales.

Les bandes analogiques sont les plus répandues dans le commerce et les moins couteuses car l’ensemble des LEDs qui la constitue (généralement des SMD5050 qui intègrent 3 LEDS : une rouge, une bleue et une verte) sont connectées en parallèle. On contrôle ainsi la couleur de toutes les LEDs en modulant le signal avec une sortie analogique PWM (et quelques MOSFETs pour amplifier le signal).

Pour permettre un contrôle individuel de la couleur de chaque LED, les bandes dites « digitales » intègrent des microcontrôleurs pour pouvoir adresser chaque LED individuellement.

On trouve dans le commerce une multitude de microcontrôleurs pour cet usage (HL1606, WS2801, WS2811, LPD8603, TM1812, UCS1903, etc…) les plus répandus étant le WS2801 et le LPD8806.

Ce dernier permet de contrôler 6 canaux séparés de 7 bits. Il y a donc un microcontrôleur pour deux LEDs où chaque couleur est codée sur 21 bits soit 2 097 152 combinaisons de couleur/brillance possible.

En général il y a 32 LEDs (donc 16 microcontrôleurs LPD8806) par mètre mais certains fabricants proposent jusqu’à 52 LEDs/mètre.

image

Pour l’installation, il suffit de découper votre bande de LEDs suivant les dimensions de votre écran. Chacune de vos bandes doit être connectée en série en les reliant ensemble. Il y a deux connecteurs pour l’alimentation (5V) et deux connecteurs pour l’interface SPI (données et horloge).

Sur l’une des extrémités, vous souderez un connecteur JST 4 pôles pour la connexion à la « SLightBox ».

image

La « SLight Box »

Pour piloter le bus SPI depuis une application Windows nous utiliserons des modules .NET Gadgeteer. Il faut donc une carte mère (mainboard) Gadgeteer comme la FEZ Spider, FEZ Hydra ou moins cher, la FEZ Cerberus (ainsi que son module d’alimentation comme le module « SP Client »).

Pour la communication avec l’ordinateur nous utiliserons le module « USB-Serial » qui expose un port COM virtuel pour dialoguer depuis notre PC.

Pour le contrôle des LEDs, les cartes .NET Gadgeteer disposent d’une interface SPI sur les sockets de type « S » où la pin 7 est utilisée pour écrire les données (le MOSI) et la pin 9 pour l’horloge (SCK). Nous utiliserons le module Extender en soudant une petite barrette mâle (pas standard 2,54mm) pour faciliter les connexions.

image

L’ensemble de ces modules sera installé dans une petite boite en plastique avec une connectique pour :

  • l’alimentation 5V,
  • le connecteur USB du module « USB-Serial »,
  • le connecteur JST vers les bandes de LEDs.

En façade :

  • un interrupteur,
  • une LED témoin rouge d’alimentation.

image image

L’entrée 5V est coupée par l’interrupteur puis alimente le module SP (donc la mainboard Gadgeteer), la sortie JST (pour les LEDs) et la LED témoin en façade.

figure 8 v2 image

Le software

Côté Gadgeteer

La «  SlightBox Gadgeteer » est ni plus ni moins qu’une interface USB/SPI vers les bandes de LEDs. Son rôle est simple : attendre les données du PC via le port USB et les recopier sur le port SPI.

image

Au démarrage de la carte Gadgeteer, nous initialiserons la sortie SPI sur la socket du module Extender en spécifiant l’horloge à 16mhz, ainsi que le module USB en spécifiant le débit du port COM au maximum (115200 bauds) :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Configure SPI Port
GTI.SPI.Configuration spiConfig = new GTI.SPI.Configuration(
         false,	// chip select active state
         0,		// chip select setup time
         0,		// chip select hold time
         false,	// clock idle state
         true,	// clock edge (true = rising)
         16000);	// 16mhz
mLedStrip = new GTI.SPI(Socket.GetSocket(extender.ExtenderSocketNumber, true, extender, null), spiConfig, GTI.SPI.Sharing.Exclusive, null);
// Configure USB Serial port
usbSerial.Configure(115200, Gadgeteer.Interfaces.Serial.SerialParity.None, Gadgeteer.Interfaces.Serial.SerialStopBits.One, 8);
// Open USB Serial port
usbSerial.SerialLine.Open();
// Ready !
Debug.Print("SLightBox Ready !");

Pour la suite, il suffit d’attendre les données du port USB pour les recopier sur l’interface SPI :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
while (true)
{
    if (usbSerial.SerialLine.BytesToRead > 0)
    {
        int bytesRead;
        if ((bytesRead = usbSerial.SerialLine.Read(buffer, 0, usbSerial.SerialLine.BytesToRead)) > 0)
        {
            byte[] dataToWrite = new byte[bytesRead];
            Array.Copy(buffer, dataToWrite, bytesRead);
            mLedStrip.Write(dataToWrite);
            Thread.Sleep(10);
        }
    }
    else
    {
        Thread.Sleep(1);
    }
}

La « SlightBox » est prête, il suffit de la connecter aux LEDs par le connecteur JST, au PC par un câble USB et à un transformateur 5V. En enclenchant l’interrupteur, la « SlightBox » sera détectée comme un « port COM virtuel » et attendra les données à envoyer aux LEDs !

Pour finir, n’oubliez pas de bien dimensionner la puissance de l’alimentation 5V : il faut prévoir 0,5 ampères pour les modules Gadgeteer puis 2 ampères par mètre de LEDs (une LED consomme 60mA au maximum lorsqu’on affiche du blanc. Pour 32 LEDs/mètre, on peut théoriquement consommer près de 2A).

Côté Windows

Une fois la partie « hardware » terminée, nous pouvons nous attaquer au « cœur » de cette solution : le programme Windows : Slight.

Ce programme doit être capable de capturer l’image de votre écran afin d’analyser les couleurs dominantes et les envoyer sur le port COM virtuel qui seront ensuite transmises par SPI aux LEDs via le programme Gadgeteer de la « SlightBox ».

Pour la capture de l’écran, nous nous servirons de DirectX pour des questions de performance à l’aide de SlimDX, un framework .NET open-source pour DirectX.

Par exemple pour capturer l’écran principal :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// Initialization 
this.dxDevice = new Device(
    new Direct3D(), 0, DeviceType.Hardware, IntPtr.Zero, CreateFlags.SoftwareVertexProcessing,
    new PresentParameters() { Windowed = true, SwapEffect = SwapEffect.Discard });
 
// To capture, get the screen surface
Surface surface = Surface.CreateOffscreenPlain(
                this.dxDevice,
                Screen.PrimaryScreen.Bounds.Width,
                Screen.PrimaryScreen.Bounds.Height,
                Format.A8R8G8B8, Pool.Scratch);
// Capture surface screen buffer data
Surface screenSurface = this.dxDevice.GetFrontBufferData(0, surface);
DataRectangle screenRectangle = screenSurface.LockRectangle(LockFlags.None);
DataStream screenDataStream = screenRectangle.Data;
 
// - Do work -
 
// Dispose screen surface
screenSurface.UnlockRectangle();
screenSurface.Dispose();

Le “DataStream” est un flux où chaque pixel est représenté sur 4 bits (B, G, R, A).

Au démarrage le programme Slight calcule les coordonnées de chaque zone en fonction de la disposition des bandes de LEDs et de la résolution de l’écran. On sélectionne ensuite les coordonnées d’un pixel sur vingt dans cette zone comme échantillon pour calculer la couleur moyenne de la zone.

Comme chaque zone est associée à une LED uniquement, nous ajouterons des Panels dans notre fenêtre pour visualiser les couleurs calculées pour chaque LED.

A la fin de l’initialisation nous disposons donc de la position dans le DataStream de chaque « pixel échantillon » pour chaque zone.

A l’aide d’un « Timer » déclenché toutes les 50ms, nous capturerons le DataStream de l’écran afin de calculer la couleur moyenne de chaque zone par la méthode GetColorAverage :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
private Color GetColorAverage(DataStream screenDataStream, Collection positions)
{
    byte[] buffer = new byte[BITS_PER_PIXEL];
    int r = 0, g = 0, b = 0, count = 0;
    // For each pixels
    foreach (long pos in positions)
    {
        screenDataStream.Position = pos;
        screenDataStream.Read(buffer, 0, BITS_PER_PIXEL);
        r += buffer[2];
        g += buffer[1];
        b += buffer[0];
        count++;
    }
    // Return the average color for the list of pixels
    return Color.FromArgb(r / count, g / count, b / count);
}

Pour adresser la couleur à la bonne LED nous devons écrire la liste des couleurs des zones les unes derrière les autres.

Pour rappel, avec le LPD8806 les couleurs sont définies en GRB (Vert, Rouge, Bleu) sur 7 bits. On pourrait donc diviser la valeur capturée du R, G et B par deux. Néanmoins pour rendre les couleurs plus riches, nous appliquerons une petite correction gamma : (127 * (La_Couleur_sur_8_bits / 255) ^ Correction_Gamma) + 0.5 (où « Correction_Gamma » est par défaut à 2,5 mais peut varier entre 1 et 5 en fonction de vos préférences).

Ainsi pour chaque capture :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
byte[] colorData = new byte[ledBytesCount];
// For each zones (= for each leds)
for (int i = 0; i < numberOfLeds; i++) 
{
    Color pixelColor = Color.Black;
    if (pixelsList.Count > i)
    {
        // Get color average
        pixelColor = this.GetColorAverage(screenDataStream, pixelsList[i]);
        // Update UI
        this.updatePanelColorActions[i](pixelColor);
    }
    // Build colorData
    int index = i * BITS_PER_LED;
    if (this.GammaCorrectionEnabled)
    {
        colorData[index + 0] = (byte)(LPD8806_MASK | (byte)(Math.Pow((double)pixelColor.G / 255.0, this.gammaCorrectionValue) * 127.0 + 0.5));
        colorData[index + 1] = (byte)(LPD8806_MASK | (byte)(Math.Pow((double)pixelColor.R / 255.0, this.gammaCorrectionValue) * 127.0 + 0.5));
        colorData[index + 2] = (byte)(LPD8806_MASK | (byte)(Math.Pow((double)pixelColor.B / 255.0, this.gammaCorrectionValue) * 127.0 + 0.5));
    }
    else
    {
        colorData[index + 0] = (byte)(LPD8806_MASK | (pixelColor.G / 2));
        colorData[index + 1] = (byte)(LPD8806_MASK | (pixelColor.R / 2));
        colorData[index + 2] = (byte)(LPD8806_MASK | (pixelColor.B / 2));
    }
}
// Send datas to the SerialPort
byte[] datas = new byte[ledBytesCount + LPD8806_LATCH_BITS];
Array.Copy(colorData, 0, datas, LPD8806_LATCH_BITS, ledBytesCount);
this.port.Write(datas, 0, datas.Length);

Avec les déclarations suivantes :

1
2
3
4
5
6
SerialPort port = new SerialPort("COMx", 115200, Parity.None, 8, StopBits.One);
const int BITS_PER_PIXEL = 4; 
const int BITS_PER_LED = 3; 
const int LPD8806_LATCH_BITS = 21;
const byte LPD8806_MASK = 0x80;
int ledBytesCount = numberOfLeds * BITS_PER_LED;

Le tableau d’actions « updatePanelColorActions » permet de mettre à jour la couleur du Panel associée dans la fenêtre :

image

Voilà l’application terminée, il ne reste plus qu’à tester son bon fonctionnement et ses performances grâce à des vidéos de test spécialement conçues pour Ambilight que vous trouverez sur YouTube.

image

Nous pouvons encore enrichir son fonctionnement en ajoutant la capacité de s’adapter dynamiquement au format de la vidéo ! En effet, lorsque vous regardez une vidéo en 4:3 ou 21:9 sur un écran 16:9 vous n’échapperez pas aux bandes noires horizontales ou verticales. Les zones calculées par Slight risqueraient de ne « rien voir » d’autre que du noir sur certain bord.

Pour combler cette lacune, il faut recalculer les coordonnées des zones en prenant compte de la taille des bandes noires.

Pour cela, au démarrage de l’application, on calcule les coordonnées des pixels d’une ligne fictive partant de chaque bord de l’écran vers le centre.

Plusieurs fois par seconde, on remonte cette ligne tant que le pixel est noir ! Dès lors qu’il ne l’est plus, cela signifie alors que nous sommes au début du contenu vidéo !

Pour éviter un comportement instable, chaque côté utilise trois lignes différentes (au ¼, ½ et ¾) où chaque pixel de couleur trouvé doit être à la même distance du bord sur les deux autres lignes. De plus, le redimensionnement n’a lieu que si les dix dernières mesures ont donné le même résultat.

Ainsi peu importe le contenu vidéo, Slight s’adaptera en toute circonstance !

Conclusion

Le résultat en vidéo :

Comme vous l’avez découvert dans cet article, la réalisation d’un système Ambilight pour PC est relativement aisée à entreprendre avec quelques modules Gadgeteer, un Visual Studio et quelques composants, sans oublier les bandes de LEDs digitales.

Les modules Gadgeteer sont très pratiques pour confectionner des prototypes de tout genre bien que dans ce projet ils soient largement sous-utilisés.

Pour rendre le système moins cher, la « SlightBox v2 » est basée sur une puce MCP2210 USB/SPI dédiée et remplace ainsi les 4 modules Gadgeteer. L’application Windows reste la même dans sa logique mais communique avec la SlightBox non pas via un port COM virtuel du module Gadgeteer mais par le driver HID du fabricant de cette puce.

Pour aller encore plus loin, la « SlightBox v3 » sort du cadre du PC : branchez-la directement sur vos périphériques HDMI (box internet, câble/satellite, DVD/Bluray, consoles de jeux, etc..) et profitez des avantages de Slight sur votre TV sans aucun PC !

Retrouvez plus d’informations et photos sur la page Facebook SlightBox.