Contrôlez votre maison avec la télécommande de la TV–ou comment envoyer et recevoir des signaux infrarouges avec un ESP8266 et Constellation
Suite à la publication dans le magazine Programmez! de mon dossier sur les ESP8266, des microcontrôleurs équipés d’une interface Wifi, je vous propose ici la réalisation d’une passerelle infrarouge dans Constellation pour moins de 10€.
Grâce à celle-ci, vous pourrez envoyer ou recevoir des signaux infrarouges (IR) depuis vos programmes, scripts, pages Web ou objets connectés dans Constellation.
Après une introduction au monde du signal infrarouge, je vous expliquerai comment j’ai pu porter l’excellente librairie Arduino “IRremote” sur ESP8266 et comment l’intégrer dans Constellation.
Nous exploiterons cette passerelle pour :
- Piloter des appareils IR depuis une application Web ou Android avec 5 lignes de JavaScript ou même un script Powershell
- Piloter une scène BabylonJS ou sa maison (domotique Z-Wave, lampes Hue, thermostat Nest ou media-center Kodi) depuis une simple télécommande infrarouge
Bonne découverte …
Introduction
Imaginez que vous vous installiez confortablement dans votre canapé, attrapiez la télécommande et allumiez la TV juste à temps pour le film quand vous vous apercevez que vous avez oublié de fermer les lumières de la cuisine…
En geek averti, vous avez bien sûr le contrôle de vos lumières sur votre smartphone grâce à votre box domotique…mais où avez-vous bien pu laisser votre téléphone ?
Après l’avoir retrouvé et déverrouillé, vous lancez votre application domotique, naviguez dans la catégorie “cuisine” pour pouvoir enfin éteindre les lampes.
Le film commence…..
Pour être dans l’ambiance, vous démarrez également (toujours depuis votre Smartphone) l’application Hue pour diminuerl’intensité de vos ampoules connectées Philips Hue du salon.
Fin prêt pour votre moment cinéma lorsqu’un frisson vous rappelle qu’il fait un peu froid. Vous décidez alors de monter lethermostat de quelques degrés : retour sur le smartphone pour lancer l’application Nest et augmenter la température de consigne!
Vous êtes satisfait, vous avez contrôlé tout cela sans bouger de votre canapé…mais avouez que c’était tout de même assez laborieux ! Il faut se l’avouer, des fois on irait plus vite à se lever pour appuyer sur l’interrupteur et baisser le thermostat manuellement 
Pour améliorer cela, plusieurs solutions :
- Avoir une application de contrôle universel : avec une plateforme d’interconnexion des objets et services connectés comme Constellation. On peut concevoir des applications de type S-Panel optimisée sur les fonctionnalités essentielles. Après, ça reste une application sur smartphone et/ou tablette.
- Une télécommande : une télécommande domotique coûte assez chère et elle est limitée aux fonctionnalités de votre box et aux nombres de touches de ladite télécommande (une Minimote n’a que 4 touches !).
- Avoir une “IA” permettant d’automatiser certaines tâches : par exemple chez moi, lorsqu’un film démarre sur un XBMC/Kodi, la maison ajuste la T°, coupe les lumières de la salle à manger / cuisine, démarre S-Light, configure les lampes “Hue” en mode film…. mais le “cerveau domotique” ne peut pas tout anticiper !
Personnellement quand je m’installe dans mon canapé, non loin de moi, j’ai déjà une télécommande à ma disposition : celle de ma TV qui me permet de l’allumer, de changer de chaines ou le volume !
Et sur ces télécommandes, il y a toujours plein de touches qui ne servent à rien ! Alors pourquoi ne pas utiliser cette télécommande (ou une autre) pour contrôler également tout ce dont j’ai besoin lorsque je suis dans mon canapé : le thermostat, les lumières (Z-Wave, Hue ou autre), mon media-center, etc..
Partant de cette idée, il me faut un récepteur infrarouge ! Et quitte à avoir un récepteur, ajoutons également un émetteur et créons ainsi une passerelle infrarouge bidirectionnelle, c’est à dire capable d’envoyer des signaux infrarouges mais également de les recevoir. Et bien sûr tout cela connecté dans la Constellation pour décupler les possibilités !
Ainsi piloter votre TV depuis une page HTML en JavaScript ou vice-versa, piloter une page HTML avec la télécommande TV devient un jeu d’enfant !
Les ESP8266
Si vous ne connaissez pas encore les ESP8266, je vous invite à lire mon dossier dans le magazine Programmez!
En quelques mots, l’ESP8266 est un microcontrôleur 80Mhz équipé d’une interface Wifi. Il existe plusieurs modèles et personnellement je travaille essentiellement avec l’ESP-01 produit par AI-Thinker :
Avec un prix avoisinant 2-3 euros, il est le compagnon idéal pour créer tout type d’objet connecté. Je vous recommande par la même occasion la création d’une plaque de programmation comme expliqué ici.
Vous avez plusieurs manières de développer sur les ESP8266 : en utilisant l’ESP comme une passerelle (firmware AT, ESPduino, ..) ou de manière autonome en C++ avec les SDK natifs ou en utilisant des firmwares comme NodeMCU pour développer en Lua ou encore le firmware ESP-Arduino pour profiter d’un environnement de développement simple et familier (lire le dossier dans le magazine Programmez).
La plateforme Constellation dispose d’une librairie pour ESP/Arduino permettant de connecter ces petites puces dans la Constellation. Elles pourront alors envoyer ou recevoir des messages avec les autres systèmes connectés (un Arduino, un Gadgeteer, un programme .NET ou Python, une page Web, etc…) et également produire ou s’abonner à des StateObjects.
Par exemple, un ESP peut piloter une matrice de LED indiquant en temps réel l’état de vos zones de l‘alarme Paradox en quelques lignes :
Ou encore piloter en temps réel un anneau de LED depuis une page Web avec 5 lignes de code JavaScript :
On peut également créer des capteurs en tout genre. Par exemple, je vous avais présenté comment élaborer un capteur de luminosité pour 7€ (très pratique pour orchestrer les lumières du salon) :
Bref, l’ESP8266 est le microcontrôleur parfait pour créer une passerelle infrarouge connectée dans Constellation.
Les signaux infrarouges : la théorie
Une télécommande émet un signal infrarouge (donc invisible à l’œil nu) qui est capté et décodé par un récepteur.
Ce signal invisible est une sorte de morse lumineux : on fait “clignoter” une LED infrarouge d’une certaine façon pour encoder un message afin d’allumer ou éteindre la TV, monter ou descendre le volume, changer de chaine, etc.
Bien que cette lumière ne soit pas visible à l’œil nu, vous pouvez la voir à travers un appareil photo ou une caméra :
La plupart des émetteurs-récepteurs infrarouges fonctionnent sur une fréquence de 38kHz soit une période d’environ 26µs. On module donc l’émission (et la réception) d’une lumière IR à cette fréquence de manière à filtrer la pollution d’infrarouge (le soleil par exemple émet des IR). Ainsi toute réception de lumière IR qui n’est pas accordée sur cette fréquence sera ignorée.
Ensuite chaque constructeur va définir sa propre méthode pour moduler son signal infrarouge et pour encoder/décoder des messages. On retrouve un protocole particulier chez Sony, Samsung, NEC, JVC, etc. Parfois le même constructeur peut créer plusieurs protocoles comme Philips avec le RC-5, RC-6 ou le RC-MM.
La modulation va consister à définir comment envoyer un “1” et un “0” logique. En clair, comment coder/décoder un code binaire avec une lumière IR. Le protocole définit le format d’un message et son protocole d’échange.
Par exemple avec le protocole NEC, une impulsion doit durer 560µs. A une fréquence de 38kHz on doit donc allumer et éteindre la LED IR 21 fois (21 * 26µs = 560 µs). Un “1” logique dure 2,25ms, c’est à dire qu’on doit faire une impulsion de 560µs puis on marque une pause de 1690µs (560 + 1690 = 2250µs = 2,25ms). Pour un “0” logique, c’est 1,12ms, soit une impulsion suivi d’une pause de 560µs chacune.
Le fait de faire une impulsion (émission d’IR) est appelé “mark” et lorsque l’on n’émet pas, on appelle cela “space”.
Avant de transmettre un message, on commence par un “mark” spécial indiquant le début d’un nouveau message. Sur le protocole NEC ce “mark” d’initialisation dure 9ms suivi d’un “space” de 4,5ms.
Le protocole NEC se résume par les constantes suivantes :
- “Mark” d’initialisation = 9000µs
- “Space” d’initialisation = 4500µs
- “Mark” de bit = 560µs
- “Space” pour un “1” = 1690µs
- “Space” pour un “0” = 560µs
Avec le protocole NEC on transmet un code composé d’une adresse codée sur 8bits et d’une commande codée également sur 8 bits (soit un message de 16 bits au total). L’adresse et la commande sont transmises deux fois de suite pour vérification.
De ce fait, pour émettre un code, il suffit de faire “clignoter” une LED infrarouge à une fréquence de 38kHz en prenant en compte la modulation et protocole du message que l’on veut envoyer.
Pour la réception, on utilisera un récepteur infrarouge de 38kHz connecté sur une entrée digitale. Cette entrée sera à l’état “high” lorsqu’un signal IR est reçu (= “mark”) et “low” si rien (= “space”).
En utilisant une boucle, on comptera le temps de chaque changement d’état de notre entrée. On en déduira ainsi le temps de chaque “mark” et de chaque “space” pour pouvoir ensuite de décoder le code IR tenant compte des spécificités de chaque protocole.
Pour en savoir plus sur l’émission et la réception de signaux IR et les différents protocoles je vous recommande vivement ce site : http://www.sbprojects.com/knowledge/ir/index.php.
Envoyer et recevoir des signaux infrarouges avec un ESP8266
D’un point de vue conception, nous avons besoin d’une simple LED infrarouge pour pouvoir émettre et un récepteur infrarouge 38kHz pour recevoir.
Le récepteur sera alimenté en 3,3V et connecté sur un des GPIO de l’ESP. Pour l’émission, on a juste à connecter la LED IR sur un autre GPIO avec sa résistance adaptée.
Par ailleurs, je vous conseille de connecter la LED IR sur un autre GPIO que le “0” pour éviter de rentrer en “Flash mode” au démarrage. Typiquement, le “RX” peut être utilisé comme GPIO (le GPIO3) (relire l’introduction).
Le schéma de notre passerelle est donc relativement simple :
Pour le valider le “POC”, réalisons notre passerelle sur une breadboard :
Côté software, ce fut un peu plus compliqué à mettre au point !
Il existe bien la fameuse librairie pour Arduino “IRremote” initiée par Ken Shirriff. Seulement cette librairie n’est pas compatible en l’état sur les ESP8266 car l’implémentation, à la fois pour l’émission et la réception des signaux infrarouges, est trop dépendante du hardware des Arduino : les ATmegas.
En effet, pour émettre un signal IR on doit allumer notre LED IR à une certaine fréquence (38kHz) pour créer des “marks” et des “spaces”. La librairie utilise les méthodes space() et mark() (voir irSend.cpp) pour piloter la LED en PWM avec les macros TIMER_ENABLE_PWM et TIMER_DISABLE_PWM.
Ces deux macros sont définies dans le fichier IRremoteInt.h et dépend du hardware utilisé.
Par exemple les Arduino sur ATmegas (Mega, Duemilanove, Diecimila, LilyPad, Mini, Fio, Nano, etc.) utilisent le Timer2 (8 bits). Les macros sont déclarées de la façon suivante :
1 2 | #define TIMER_ENABLE_PWM (TCCR2A |= _BV(COM2B1)) #define TIMER_DISABLE_PWM (TCCR2A &= ~(_BV(COM2B1))) |
TCCR2A est un “Timer Counter Register” permettant de générer un signal PWM directement depuis le hardware. Toujours par Ken Shirriff, je vous invite à lire son article Secrets of Arduino PWM.
Mais cela n’est pas possible sur un ESP8266. On va devoir générer notre signal PWM manuellement (technique dite du “Bit-banging Pulse Width Modulation”) en marquant des pauses au niveau software.
Ainsi on définit les fonctions mark et space de la façon suivante :
1 2 3 4 5 6 7 8 9 10 11 | void IRsend::mark(int time) { // Sends an IR mark for the specified number of microseconds. // The mark output is modulated at the PWM frequency. long beginning = micros(); while(micros() - beginning < time){ digitalWrite(IRpin, HIGH); delayMicroseconds(halfPeriodicTime); digitalWrite(IRpin, LOW); delayMicroseconds(halfPeriodicTime); //38 kHz -> T = 26.31 microsec (periodic time), half of it is 13 } } |
Lors d’un “mark()”, on allume la LED le temps voulu en la faisant “clignoter” à une fréquence de 38kHZ. Un space() n’est ni plus ni moins qu’une pause du temps voulu avec la LED éteinte.
Cette adaptation a été réalisée par Mark Szabo afin de pouvoir utiliser la librairie IRremote sur ESP8266 pour l’émission seulement.
Pour la réception j’ai forké son projet sur mon Github pour implémenter cette partie.
En effet, la librairie originale IRremote utilise l’Interrupt Service Routine (ISR) du Timer2 (propre aux ATmegas) pour déclencher toutes les 50µS une fonction qui enregistre dans un buffer les temps de “mark” et de “space” captés par le récepteur IR. Voir IRremote.cpp :
1 2 3 4 | ISR (TIMER_INTR_NAME) { // Read if IR Receiver -> SPACE [xmt LED off] or a MARK [xmt LED on] uint8_t irdata = (uint8_t)digitalRead(irparams.recvpin); |
Le problème est le même que l’émission : ce n’est pas compatible sur un ESP8266 !
Pour contourner le problème je vais utiliser le système d’interruption natif de l’ESP8266. Le SDK officiel d’Expressif me permet de configurer une interruption sur le changement d’état d’un GPIO.
L’idée est donc d’invoquer une fonction dès que le GPIO (= le récepteur) change d’état (High –> Low ou Low –> High), c’est à dire qu’il “capte” ou “perd” un signal IR.
Pour accéder au SDK natif de l’ESP8266 depuis votre code Arduino, il faut utiliser le mot clé “extern” :
1 2 3 4 | extern "C" { #include "user_interface.h" #include "gpio.h" } |
A l’initialisation (IRrecv::enableIRIn), on définit une interruption sur le changement d’état du GPIO sur lequel est connecté le récepteur (irparams.recvpin) qu’on attache sur une fonction nommée “gpio_intr” :
1 2 3 4 5 | // ESP Attach Interrupt ETS_GPIO_INTR_DISABLE(); ETS_GPIO_INTR_ATTACH(gpio_intr, NULL); gpio_pin_intr_state_set(GPIO_ID_PIN(irparams.recvpin), GPIO_PIN_INTR_ANYEDGE); ETS_GPIO_INTR_ENABLE(); |
Ainsi la fonction “gpio_intr” sera appelée dès que le récepteur change d’état (GPIO_PIN_INTR_ANYEDGE). A chaque changement d’état, c’est soit qu’on “capte” un signal IR soit qu’on l’a perdu.
Pour gagner en performance j’utilise les fonctions du SDK natif “GPIO_REG_READ” pour lire l’état du GPIO à la place du digitalRead() de l’Arduino. Au final on remplit le buffer de la même manière que la librairie originale sur Arduino pour conserver le même code de décodage. A la fin cette fonction, on (re)démarre un timer pour s’exécuter dans 15ms.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | static void ICACHE_FLASH_ATTR gpio_intr(void *arg) { uint32_t gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS); GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status); if (irparams.rcvstate == STATE_STOP) { return; } static uint32_t start = 0; uint32_t now = system_get_time(); if (irparams.rcvstate == STATE_IDLE) { irparams.rcvstate = STATE_MARK; } else if (irparams.rawlen < RAWBUF) { irparams.rawbuf[irparams.rawlen++] = (now - start) / USECPERTICK + 1; } start = now; os_timer_disarm(&timer); os_timer_arm(&timer, 15, 0); } |
Ce timer est déclaré comme un ETSTimer, une structure qui fait partie du SDK d’Expressif :
1 | static ETSTimer timer; |
Lors de l’initialisation on l’attache sur la fonction “read_timeout” :
1 2 3 | // Initialize timer os_timer_disarm(&timer); os_timer_setfn(&timer, (os_timer_func_t *)read_timeout, &timer); |
Ainsi, si l’état de notre GPIO n’a pas changé durant les 15 dernières millisecondes, la fonction “read_timeout” s’exécutera pour arrêter la lecture si le buffer est rempli (en bloquant le système d’interruption par la fonction os_intr_lock) :
1 2 3 4 5 6 7 | static void ICACHE_FLASH_ATTR read_timeout(void *arg) { os_intr_lock(); if (irparams.rawlen) { irparams.rcvstate = STATE_STOP; } os_intr_unlock(); } |
Pour la suite, le fonctionnement est strictement identique au celui de la librairie d’origine, on appelle depuis notre sketch Arduino la fonction “IRrecv::decode()” qui tentera de décoder le protocole utilisé et le contenu du message compte tenu des temps de “mark” et de “space” capturés avant de réenclencher la capture des signaux IR (IRrecv::resume).
L’ensemble de mon code a été publié sur mon Github et fusionné dans le dépôt de Mark Szabo.
Il suffit donc de télécharger notre librairie et de l’utiliser de la même manière que sur un Arduino.
Exemple pour envoyer un code depuis la librairie (ici en utilisant le protocole NEC) :
1 2 3 4 5 6 7 8 9 10 11 12 | #include <IRremoteESP8266.h> IRsend irsend(0); //an IR led is connected to GPIO pin 0 void setup() { irsend.begin(); } void loop() { irsend.sendNEC(0x00FFE01F, 36); } |
Un autre exemple pour recevoir et décoder des signaux:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | #include <IRremoteESP8266.h> int RECV_PIN = 2; //an IR detector/demodulatord is connected to GPIO pin 2 IRrecv irrecv(RECV_PIN); decode_results results; void setup() { Serial.begin(9600); irrecv.enableIRIn(); // Start the receiver } void loop() { if (irrecv.decode(&results)) { // Print value Serial.println(results.value, HEX); irrecv.resume(); // Receive the next value } } |
Retrouvez tous les exemples d’utilisation de la librairie sur le dépôt Github.
Envoyer et recevoir des signaux infrarouges depuis Constellation
Jusqu’à présent on est capable d’envoyer et de recevoir des signaux infrarouges depuis un ESP8266. La prochaine étape est donc de connecter notre ESP8266 à Constellation pour exposer les fonctionnalités de la passerelle aux autres systèmes connectés dans Constellation.
Les fonctionnalités de notre passerelle sont donc :
- Envoyer un signal IR
- Recevoir un signal IR
Pour cela, nous allons utiliser un des trois grands principes de Constellation : le hub de message. L’idée finale est donc :
- Envoyer un signal IR lorsque l’on reçoit un message depuis Constellation
- Envoyer un message dans Constellation lorsque l’on reçoit/décode un signal IR
Pour démarrer ajoutons les librairies nécessaires : le Wifi de l’ESP8266, la librairie Constellation et sa dépendance à ArduinoJson ainsi que notre libraire IRremoteESP826 détaillée ci-dessus.
1 2 3 4 | #include <ESP8266WiFi.h> #include <ArduinoJson.h> #include <Constellation.h> #include <IRremoteESP826.h> |
Déclarons notre client Wifi (propre à l’ESP) ainsi que le SSID et la clé d’accès pour se connecter au réseau Wifi :
1 2 3 | WiFiClient wifiClient; const char* ssid = "MON-WIFI"; const char* password = "mon_password_wifi"; |
Ensuite déclarons le client Constellation qui prend en paramètre :
- La référence du client réseau à utiliser, ici le WifiClient de l’ESP8266
- L’adresse et port de votre serveur Constellation
- Le nom de la sentinelle (ici “ESP8266”), le nom du package (ici “IRremote”) et pour finir la clé d’accès Constellation
Dans le code cela donne :
1 | Constellation constellation(wifiClient, "192.168.0.22", 8888, "ESP8266", "IRremote", "Mon_access_key"); |
Bien entendu, il faut au préalable déclarer votre sentinelle ESP8226, son package et sa clé d’accès sur votre Constellation.
A partir du “Constellation Configuration Manager” cela se fait très facilement en quelques clics. Il faut d’abord créer une clé d’accès :
Puis on déclare une sentinelle “ESP8266” en l’associant à la clé d’accès souhaitée :
Et pour finir on déclare un package, ici nommé “IRremote” sur notre sentinelle ESP8266 :
Notre ESP8266 peut maintenant se connecter à notre Constellation.
Pour revenir à notre code Arduino, on peut déclarer les autres variables nécessaires et initialiser la classe d’émission d’IR sur la GPIO3 (RX) et le récepteur sur la GPIO2.
Déclarons également deux booléens pour indiquer si on active la réception et l’émission et le nom d’un groupe pour l’envoi des signaux décodés (expliqué un peu plus bas) :
1 2 3 4 5 6 7 8 9 | StaticJsonBuffer<200> jsonBuffer; IRsend irsend(3); // GPIO3 (RX) IRrecv irrecv(2); // GPIO2 decode_results results; boolean enableReceiver = false; boolean enableEmitter = false; const char* irGroupRecipient; |
Dans le setup(), je peux donc me connecter sur le réseau Wifi :
1 2 3 4 5 6 7 8 9 10 11 | // Connect to Wifi Serial.print("Connecting to "); Serial.println(ssid); WiFi.mode(WIFI_STA); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println("WiFi connected. IP: "); Serial.println(WiFi.localIP()); |
Juste après la connexion, je vais récupérer les settings de mon package Constellation pour savoir si j’active la réception et l’émission :
1 2 3 4 | // Get settings JsonObject& settings = constellation.getSettings(); enableReceiver = String(settings["EnableReceiver"].asString()) == "true"; enableEmitter = String(settings["EnableEmitter"].asString()) == "true"; |
Les settings Constellation permettent de centraliser l’ensemble des paramètres de configuration de tous les packages (objets, programmes, etc…) depuis un point unique : le serveur Constellation.
Avec le Configuration Manager, je peux très facilement éditer les paramètres de mon package :
Ainsi, il me sera possible de changer le comportement de mon ESP8266 directement depuis le serveur Constellation.
Dans le cas de la passerelle IR, en cas de réception d’un signal IR, je veux envoyer un message dans la Constellation pour indiquer qu’on a décodé un signal IR. Seulement je ne sais pas à qui l’envoyer, car la passerelle ne sait pas qui est intéressé !
La solution est donc d’envoyer le message à un groupe Constellation. Si un programme C# ou Python, une page Web ou que sais-je, souhaite interagir avec la télécommande, ils n’auront qu’à s’abonner à ce groupe.
Pour ajouter encore plus de souplesse, le nom du groupe est lui-même un paramètre de mon package Constellation. Ici le nom du groupe est “IR”.
Pour terminer le démarrage de notre ESP8266, après avoir récupérer les settings de notre package, on va activer le récepteur et l’émetteur IR en fonction des settings définis sur le serveur. De plus si l’émission est activée, on va s’abonner aux messages entrants :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | // Start IR decoder and/or emitter if(enableReceiver) { String strIRGroupRecipient = String(settings["IRGroupRecipient"].asString()); static char irGroup[STRING_FORMAT_BUFFER]; strIRGroupRecipient.toCharArray(irGroup, strIRGroupRecipient.length() + 1); irGroupRecipient = irGroup; irrecv.enableIRIn(); // Start the receiver } if(enableEmitter) { irsend.begin(); // Set callback for incoming message constellation.setMessageReceiveCallback(messageReceive); constellation.subscribeToMessage(); } |
Enfin, on écrit une information pour indiquer que notre passerelle IR est démarrée :
1 | constellation.writeInfo("ESP IR device '%s' is started. Emitter: %s - Receiver: %s", constellation.getSentinelName(), (enableEmitter ? "ON" : "OFF" ), (enableReceiver ? "ON" : "OFF" )); |
Et comme vous le savez, tous les packages et sentinelles remontent en temps réel leurs logs dans la Constellation, ce qui me permet depuis la Web Console par exemple, de voir mon ESP démarrer :
Dans la boucle principale :
- Si la réception est activée, je tente de décoder un signal. Si un signal IR est décodé, j’envoie le code IR dans un message nommé “SignalReceive” au groupe configuré (le paramètre “irGroupRecipient”)
- Si l’émission est activée, j’interroge Constellation pour prendre connaissance des messages entrants
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | void loop() { if(enableReceiver) { if (irrecv.decode(&results)) { if(results.decode_type != UNKNOWN) { unsigned long value = results.value; constellation.sendMessage("Groups", irGroupRecipient, "SignalReceive", "%#x", value); constellation.writeInfo("Receiving IR code '%#x'", value); } irrecv.resume(); } } if(enableEmitter) { constellation.pollConstellation(1000); delay(100); } } |
En cas de décodage d’un signal IR, on écrira une trace dans les logs Constellation après avoir envoyé le code dans un message “SignalReceive” au groupe :
Si le mode “émetteur” est activé, on récupère les messages entrants par la méthode “pollConstellation” qui déclenchera la méthode “messageReceive” (spécifié dans le setup via la méthode “setMessageReceiveCallback”).
Dans notre cas, la méthode “messageReceive” regardera la clé du message (Key) que l’on reçoit. Si la clé est “SendCode”, on récupère dans le contenu du message reçu (Data) le protocole (Encoding) à utiliser et le code à envoyer puis, avec notre classe IRsend, on émet le signal IR.
A noter que dans mon implémentation ci-dessous je ne gère que le protocole Samsung et Panasonic (car je n’ai que çà chez moi 
).
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | void messageReceive(JsonObject& json) { Serial.print("Message receive : "); const char * key = json["Key"].asString(); if (stricmp (key, "SendCode") == 0) { const char * encoder = json["Data"]["Encoding"].asString(); unsigned long code = strtoul(json["Data"]["Code"].asString(), NULL, 0); irrecv.disableIRIn(); if (stricmp (encoder, "Samsung") == 0) { constellation.writeInfo("Send IR code '%#x' (Samsung)", code); irsend.sendSAMSUNG(code, 32); } else if (stricmp (encoder, "Panasonic") == 0) { constellation.writeInfo("Send IR code '%#x' (Panasonic)", code); irsend.sendPanasonic(code, code); } else { constellation.writeInfo("Unable to send IR code : encoding '%s' not found !", encoder); } irrecv.enableIRIn(); } } |
Et voilà, notre passerelle est donc opérationnelle. Je peux lui envoyer des messages “SendCode” pour envoyer des signaux IR et si elle capte un signal, elle l’envoie dans Constellation à destination du groupe “IR”.
Il ne reste plus qu’à l’exploiter tout çà !
Créer une passerelle infrarouge “WAF compliant”
Avant d’installer notre passerelle IR dans la maison, packageons-la dans un petit boitier car une breadboard n’est pas très WAF
Pour cela j’ai utilisé un boitier noir ABS de 8,5cm de long, 5cm de large et 2,9cm d’épaisseur trouvé chez Conrad.
Il faudra percer trois trous : un pour le connecteur d’alimentation, un autre pour la LED infrarouge et un dernier pour le récepteur IR.
Sur une plaque époxy découpée aux dimensions du boitier, souder un header femelle de 4×2 pour pouvoir déposer notre ESP8266. Ajoutez un régulateur 3,3v (type LM1117) et deux condensateurs 10uF pour obtenir une alimentation stable à partir d’une source de 5 à 15V.
Connectez ensuite la LED IR au GPIO3 avec sa résistance associée et le récepteur IR sur le GPIO2. Pour rappel le schéma est le suivant :
Il ne reste plus qu’à installer la carte dans son boitier et déposer l’ESP8266 sur son socle après l’avoir programmé.
Et voilà notre passerelle infrarouge connectée dans Constellation prête à l’emploi. Installez-là où bon vous sembles en utilisant une alimentation de 5 à 15V :
Émettre des signaux infrarouges : contrôler sa TV avec une page Web, un script Powershell, une application Windows, un Raspberry ou un Gadgeteer….
Comme nous l’avons vu, lorsque que l’émission est activée (configurable dans les Settings du package), l’ESP8266 s’abonne à la réception de message.
Si la clé du message est “SendCode”, on s’attend à avoir en paramètre un objet JSON avec une propriété “Encoding” et la valeur du “Code” à émettre.
Dans un package Constellation écrit en C#/.NET (application Console, Windows ou un service), pour allumer ma TV Samsung (code 0xE0E040BF) on peut écrire :
1 | PackageHost.CreateScope(MessageScope.ScopeType.Sentinel, "ESP-IR-Salon").Proxy.SendCode(new { Encoding = "Samsung", Code = 0xE0E040BF }); |
De la même manière, si je veux allumer ou éteindre ma TV Samsung depuis un code Python, à partir d’un Raspberry connecté à Constellation par exemple, j’écrirai :
1 | Constellation.SendMessage("ESP-IR-Salon", "SendCode", { "Encoding":"Samsung", "Code":0xE0E040BF }, Constellation.MessageScope.sentinel); |
Tant que vous êtes connecté à Constellation, vous pouvez envoyer un message “SendCode” à votre ESP pour émettre un signal IR !
Il est également possible d’utiliser l’API REST de Constellation pour envoyer un message dans Constellation depuis n’importe quel langage.
Par exemple, je peux écrire un script Powershell pour envoyer le message “SendCode” à notre ESP :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | param( [string]$to="ESP-IR-Salon", [string]$encoding="Samsung", [Parameter(Mandatory=$True,Position=1)] [string]$code) [string]::Format("Sending code '{0}' (encoding:{1}) to {2}",$code, $encoding, $to) $constellationBaseURI = "http://www.myConstellationServer.com/rest"; $constellationCredential = "SentinelName=Powershell&Package=Demo&AccessKey=123"; $client = New-Object System.Net.WebClient; $client.DownloadString($constellationBaseURI + "/SendMessage?" + $constellationCredential + "&scope=Sentinel&args=" + $to + "&key=SendCode&data={'Encoding': '" + $encoding + "', 'Code': " + [Convert]::ToInt64($code, 16) + " }"); Write-Host "Done"; |
Ainsi pour allumer la TV Samsung, il me suffit de taper la commande suivante :
1 | .\SendIR.ps1 E0E040BF |
Vous remarquerez que la commandlet Powershell envoie le message à la sentinelle “ESP-IR-Salon” par défaut en utilisant l’encoding “Samsung” (ces deux paramètres sont donc optionnels)
Pour allumer ou éteindre la TV de la Chambre (une Panasonic), je dois envoyer le code “100BCBD” à l’ESP de la Chambre avec l’encoding Panasonic. Toujours depuis ma console Powershell, je taperai :
1 | .\SendIR.ps1 –code 100BCBD –encoding Panasonic –to ESP-IR-Chambre |
Pour faire quelque chose de beaucoup plus “user-friendly” qu’un script Powershell, écrivons une page Web en HTML/Javascript que nous packagerons dans une application mobile pour Android avec Cordova. Je vous ai déjà présenté Cordova avec S-Panel et S-Opener.
Ici j’utilise Bootstrap pour créer de jolis boutons avec les classes CSS prédéfinies et les icones Glyphicon. Par exemple, pour créer le bouton “On/Off” :
1 2 3 | <button data-panasonicCode="100BCBD" data-samsungCode="E0E040BF" type="button" class="btn btn-danger btn-lg" aria-label="On/Off"> <span class="glyphicon glyphicon-off" aria-hidden="true"></span> </button> |
Ce qui nous donne :
J’ai donc créé plusieurs boutons HTML placés dans un simple tableau pour reproduire une télécommande classique :
Vous noterez que j’ai ajouté deux attributs personnalisés sur chaque bouton : “panasonicCode” et “samsungCode” :
1 | <button data-panasonicCode="100BCBD" data-samsungCode="E0E040BF" |
En effet, comme chez moi j’ai deux TV (une Samsung et une Panasonic), j’ai renseigné sur chaque bouton, le code de la touche pour Samsung et l’équivalent pour Panasonic. Ici le code IR du “On/Off” sur une Samsung est “E0E040BF” et “100BCBD” sur Panasonic.
Dans l’interface, j’ai également ajouté un switch (techniquement une checkbox) pour sélectionner le protocole à utiliser :
1 | <input id="encoding" type="checkbox" data-width="240" checked data-toggle="toggle" data-on="Samsung" data-off="Panasonic" data-onstyle="primary" data-offstyle="primary"> |
Ainsi le code de l’application ne fait pas plus d’une dizaine de ligne ! A chaque fois qu’on appuie sur un bouton on récupère le code à envoyer en fonction du protocole sélectionné.
Il ne reste plus qu’à envoyer le message “SendCode” dans Constellation à destination de l’ESP du Salon (ESP-IR-Salon) ou de la chambre (ESP-IR-Chambre) :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | // deviceready Event Handler onDeviceReady: function() { // Lors du clic d'un des boutons HTML de la page $(":button").click(function () { // Si la checkbox est cochée : Samsung, sinon Panasonic ! var encoding = $("#encoding").is(":checked") ? "samsung" : "panasonic" ; // On récupère le code IR à envoyer pour l'encoding sélectionné var code = $(this).attr("data-" + encoding + "code"); // On détermine l'ESP destinataire (salon ou chambre) en fonction de l'encoding var sendTo = (encoding == "samsung") ? "ESP-IR-Salon" : "ESP-IR-Chambre"; // On envoie le message dans Constellation if(code != "") { console.log("Send to " + sendTo + " (encoding:" + encoding + ") : " + code); constellation.server.sendMessage({ Scope: 'Sentinel', Args: [ sendTo ] }, 'SendCode', { 'Encoding':encoding, Code:parseInt(code,16) }); } }); // On se connecte à Constellation var constellation = $.signalR.createConstellationClient("https://www.myConstellationServer.com/constellation", "AccessKey123", "SRemote"); constellation.connection.start(); } |
Bref, 10 lignes de JavaScript avec un tableau HTML composé de boutons et je peux piloter mes deux TV Samsung et Panasonic depuis un Smartphone ou une tablette.
On peut pousser l’expérience utilisateur encore plus loin en présélectionnant automatiquement le protocole à utiliser (et donc l’ESP destinataire). Pour cela il faut connaitre où se trouve l’utilisateur : si il est dans la chambre, j’active le mode “Panasonic”, si il est dans le salon, le mode “Samsung”. Ainsi, il suffira de lancer l’application et vous contrôlerez la TV “la plus proche” !
Pour ce faire, on peut utiliser des balises iBeacons qu’on disposera à proximité des TV.
Sans trop rentrer dans les détails, une balise iBeacon est un émetteur qui utilise le protocole Bluetooth Low Energy (BLE) pour émettre un signal périodique (configurable sur la balise, en général compris entre 100ms et 30 secondes) contenant différentes caractéristiques propres à la balise comme :
- UUID : un GUID propre à votre “organisation”
- Un n° MAJOR : pour identifier un lieu par exemple
- Un n° MINOR : pour identifier une balise au sein de ce lieu
C’est donc le trio “UUID + MAJOR + MINOR” qui forme l’identifiant unique d’une balise, libre à vous de programmer vos balises comme bon vous sembles. Vous pouvez aussi définir la puissance d’émission du signal.
Quand votre téléphone (ou tablette) captera une balise et en fonction de la puissance d’émission de la balise (TX) et de la puissance de réception du signal sur votre téléphone (RSSI) vous pourrez estimer la distance qui vous sépare de cette balise (en prenant soin de lisser les résultats avec une moyenne glissante ou un filtre de Kalman par exemple).
Avec les iBeacons, il existe deux modes d’exploitation : le Ranging ou le Monitoring.
Le Ranging permet de “scanner” les balises iBeacon à proximité en remontant toutes les informations reçues pour chacune d’entre elles : UUID, Major, Minor, Tx, Rssi, etc.
Le Monitoring permet d’enregistrer une action lorsque l’on rentre ou sort d’une région, c’est à dire d’un périmètre autour de la balise et fonctionne même si votre application n’est pas lancée. Dans le cas du monitoring il faut indiquer quelles sont le ou les balises que vous souhaitez “monitorer” (en indiquant au minimum l’UUID). Le principe est le même que le geofencing GPS utilisé pour S-Opener.
Dans notre cas, on va utiliser le “Ranging”, c’est à dire que lorsque notre application mobile sera lancée, on scannera les balises à proximité. Si ces balises sont bien de notre UUID (histoire de ne pas prendre en compte celle du voisin !), on déterminera la balise la plus proche en comparant le RSSI.
Personnellement j’ai opté pour les balises vendues sur : http://ibeaconstore.fr/. Vous trouverez des iBeacons avec ou sans boitier pour respectivement 20€ HT et 25€ HT. Des balises longues portées (180 mètres) et même des balises étanches.
Je paramètre donc 2 balises avec le même UUID et le même MAJOR. Le n° “minor” sera “1” pour le Salon et “2” pour la chambre. Chaque balise aura une puissance d’émission la plus faible et une période d’émission d’une seconde pour obtenir une fréquence de rafraichissement suffisante sans trop vider la batterie.
Avec Cordova, vous pouvez utiliser le plugin “Cordova / Phonegap iBeacon” compatible iPhone et Android. Le code se résume donc à ces quelques lignes :
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 | var myUUID = 'E2C56DB5-DFFB-48D2-B060-D0F5A71096E0'; var myBeacons = new cordova.plugins.locationManager.BeaconRegion(myUUID, myUUID); // major & minor not set = wildcard !! // Callback de resultat var delegate = new cordova.plugins.locationManager.Delegate().implement({ didRangeBeaconsInRegion: function (pluginResult) { var nearestBeacon = null; // Pour toutes les balises iBeacon qu'on détecte for (i = 0; i < pluginResult.beacons.length; i++) { // Selection de la balise la plus proche (= RSSI le plus haute) if(nearestBeacon == null || pluginResult.beacons[i].rssi > nearestBeacon.rssi) { // Note : pour de meilleur résultat il faut filtrer le signal avec une moyenne glissante (buffer circulaire) ou mieux un filtre de Kalman nearestBeacon = pluginResult.beacons[i]; } } if(nearestBeacon != null) { // minor: 1 = living room = Samsung = checked || minor: 2 = Bedroom = Panasonic = unchecked; $("protocol").prop('checked', nearestBeacon.minor == 1); / } } }); cordova.plugins.locationManager.setDelegate(delegate); cordova.plugins.locationManager.requestWhenInUseAuthorization(); // Démarre le ranging cordova.plugins.locationManager.startRangingBeaconsInRegion(myBeacons).fail(console.error).done(); |
Ainsi, lorsque vous serez plus proche du salon que de la chambre, c’est le mode “Samsung” qui s’activera, autrement, c’est le mode Panasonic qui sera sélectionné !
Réception de signaux depuis une page Web, une application Windows, un Raspberry ou un Gadgeteer….
Passons maintenant à la réception des signaux IR. Comme vous l’avons vu, notre ESP envoie un message dans la Constellation à destination d’un groupe qu’on aura défini dans la configuration du package.
Notre ESP aurait pu directement envoyer des messages à destination du package Nest, Vera, Kodi ou de vos programmes C#, Python ou autre… en fonction des signaux qu’il décode !
Par exemple pour définir la température du thermostat Nest depuis notre ESP8266 (ou depuis un Arduino avec une connectivité réseau), on écrit :
1 | constellation.sendMessage("Package", "Nest", "SetTargetTemperature", value); |
Seulement dans cette architecture tout est “hardcodé” dans le microprogramme de l’ESP lui-même. Si je veux changer la logique, il faudra que je reprogramme mon ESP. Or je ne sais pas forcement à l’avance ce que je compte faire ni qui voudra connaitre les signaux IR décodés !
Le fait d’envoyer le message dans un groupe permet de déplacer la logique métier aux destinataires. Ainsi les autres packages ou pages Web, peuvent décider de rejoindre le groupe, ici nommé “IR”, et être notifié quand ce dernier décode un signal IR. A charge à eux de réagir comme bon leur semble.
Dans les packages C# il est très simple d’écrire un callback pour la réception de message :
1 2 3 4 5 | [MessageCallback(IsHidden = true)] public void SignalReceive(string code) { // Sera invoquée dès que l’ESP capte un signal } |
Le simple fait de mettre l’attribut “MessageCallback” sur cette méthode va permettre d’attacher cette méthode (ici “SignalReceive”) à la réception des messages dont la clé est “SignalReceive”. En clair, dès que notre ESP décode un signal IR, il enverra le code du signal dans un message “SignalReceive”. Côté C# cette méthode sera automatiquement invoquée avec le code passé en paramètre !
Le paramètre “IsHidden” permet de cacher ce MessageCallback dans le catalogue de MessageCallbacks de votre Constellation. En effet, chaque “MessageCallback” est référencé dans la Constellation permettant de faire de l’auto-découverte. Seulement ici il ne s’agit pas d’exposer une fonctionnalité car cette méthode n’a pas vocation à être appelé manuellement. De ce fait, on la cache de l’annuaire avec l’option “IsHidden”.
Depuis un package Python (pour un Raspberry par exemple), le concept est le même. J’écris une méthode Python “SignalReceive” que je déclare comme MessageCallback caché :
1 2 3 | @Constellation.MessageCallback(False) def SignalReceive(code): # TODO |
Un simple décorateur et/ou attribut suffit pour lier une méthode de votre code à la réception d’un message Constellation !
Dans notre cas, l’ESP envoie le message à un groupe. Il faut donc ajouter votre package au groupe en question pour pouvoir recevoir les messages “SignalReceive”.
Pour cela dans les API vous retrouverez une méthode permettant de s’inviter dans un groupe. Par exemple en .NET :
1 | PackageHost.AddToGroup("IR"); |
Sinon, le plus simple est de définir la liste des groupes dans la configuration du package sur le serveur Constellation :
1 2 3 4 | <package name="MonPackage"> <groups> <group name="IR" /> </groups> |
De ce fait vos programmes .NET ou Python peuvent interagir avec votre télécommande infrarouge.
Par exemple, pour éteindre son PC avec le bouton On/Off de la télécommande Samsung :
1 2 3 4 5 6 7 8 | [MessageCallback(IsHidden = true)] public void SignalReceive(string code) { if(code == "E0E040BF") // Si touche On/Off de la télécommande Samsung { Process.Start("shutdown","/s /t 0"); // On éteint le PC (dirty mode ;)) } } |
Sur un Raspberry on pourrait contrôler différents GPIO, etc… Bien entendu tout système connecté sur Constellation (Arduino, Gadgeteer, clients connectés sur l’API HTTP) peut recevoir les messages de notre ESP et donc réagir en fonction des signaux IR captés.
Pour conclure cette partie, contrôlons une page Web avec une télécommande IR en suivant le même principe : grâce à la librairie JavaScript, on connecte notre page Web dans notre Constellation et on s’invite dans le groupe “IR”. On ajoute ensuite un handler sur la réception de message “SignalReceive” pour recevoir les signaux infrarouges décodés par l’ESP.
Pour le fun, utilisons BabylonJS, un moteur 3D Javascript.
Pour cette démo, j’ai récupéré le code de la scène du “Train” de Romuald ROUHIER disponible sur GitHub : https://github.com/BabylonJS/Samples
L’idée est de switcher entre les différentes caméras de cette scène 3D grâce à la télécommande la TV.
Je vais donc ajouter la libraire JS de Constellation dans la page de cette démo BabylonJS et dès que je recevrai un code correspondant à une touche de ma télécommande, je changerai la caméra active de la scène BabybonJS.
Voici le code complet :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | var constellation = $.signalR.createConstellationClient("http://www.myConstellationServer.com", "MyAccessKey", "BabylonJsOnConstellationDemo"); constellation.client.onReceiveMessage(function (message) { if(message.Key == "SignalReceive" && scene) { scene.activeCamera.detachControl(canvas); switch(message.Data) { case "E0E020DF": // Key "1" scene.activeCamera = scene.cameras[0]; break; case "E0E0A05F": // Key "2" scene.activeCamera = scene.cameras[1]; break; // Etc .... } scene.activeCamera.attachControl(canvas); } }); constellation.connection.stateChanged(function (change) { if (change.newState === $.signalR.connectionState.connected) { constellation.server.subscribeMessages("IR"); } }); constellation.connection.start(); |
Testons cela dans Microsoft Edge et Google Chrome :
Vous remarquerez d’ailleurs lequel de ces deux navigateurs est plus réactif 
Et voilà comment en quelques lignes, connecter un programme, un script, un objet ou une page pour interagir avec les signaux infrarouges décodés par notre ESP8266
Contrôler la maison avec une télécommande infrarouge
A la maison, nous utilisons cette passerelle au quotidien pour contrôler…. la maison !
En effet, je me suis rendu compte que la télécommande de la TV ne servait plus vraiment étant donné que la TV est connectée sur un ampli Home-Cinéma (compatible CEC) et que je ne regarde pas la TNT depuis la TV mais plutôt depuis la box internet. Autrement dit, la télécommande Samsung n’a plus d’intérêt !
Note: il est aussi possible d’acheter une télécommande universelle infrarouge (de 5 à 15€) pour la consacrer entièrement au pilotage domotique ou encore réutiliser une ancienne télécommande pour ne pas “interférer” avec la TV.
Pour ma part, l’idée est d’exploiter toutes ces touches inutilisées pour les fonctions de base de la maison : contrôler les lumières (Z-Wave & Hue), le chauffage et le media-center Kodi.
- Les touches numérotées sont affectées aux différentes lumières Z-Wave du salon, salle à manger, couloir, jardin & co.
- Les touches de fonction “A, B, C, D” activent les différentes ambiances lumineuses configurées sur 8 lampes Hue du salon : “Eclairage normal”, “Mode film”, “Mode feu de cheminée” et “Tout Eteint”.
- Les touches “Précédent” / “Suivant” permettent de descendre ou monter le thermostat Nest avec un retour visuel sur Kodi et la touche “Rec” permet de régler le thermostat sur 20°C directement.
- Les touches de navigation et de contrôle de la lecture pour le pilotage du Kodi (voir ci-dessous).
Je rappelle que l’ESP ne fait qu’envoyer un message “SignalReceive” dans un groupe à chaque fois qu’il décode un signal IR. Dans mon cas, c’est le package “MyBrain”, le moteur de règle de la maison déjà présenté dans mon article sur les alarmes connectées, S-Energy ou encore S-Sound, qui s’abonne au groupe “IR” et réagit aux signaux IR décodés par l’ESP.
Comme nous l’avons vu, il suffit tout simplement de faire une méthode .NET avec l’attribut “MessageCallback” et d’implémenter la logique. Par exemple pour les touches numériques associées au contrôle des lumières Z-Wave :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | [MessageCallback(IsHidden = true)] public void SignalReceive(string code) { switch (code.ToUpper()) { case "E0E020DF": // 1 this.SwitchLight(this.EclairageBar); break; case "E0E0A05F": // 2 this.SwitchLight(this.EclairageEntree); break; case "E0E0609F": // 3 this.SwitchLight(this.EclairagesCouloir); break; // Etc... |
J’ai défini une méthode SwitchLight pour inverser l’état d’une lampe (en envoyant un message au package Vera en inversant son état actuel) :
1 2 3 4 5 6 7 8 | private void SwitchLight(StateObjectNotifier lightStateObject) { this.SendMessage("Vera").SetSwitchState(new { DeviceID = (int)lightObject.DynamicValue.Id, State = !(bool)lightObject.DynamicValue.Status }); } |
Chaque lampe étant une propriété .NET liée à son StateObject. J’ai donc autant de propriétés que de lampes :
1 2 | [StateObjectLink("Vera", "Eclairage Bar Cuisine")] public StateObjectNotifier EclairageBar { get; set; } |
Pour l’éclairage Hue, j’ai défini la configuration de chaque lampe dans un JSON. Il me suffit d’appliquer la configuration pour chaque touche :
1 2 3 4 5 6 7 8 9 10 11 12 | case "E0E036C9": // Red this.GetModule<Hue>().ApplyHueConfigration("Blanc chaud"); break; case "E0E028D7": // Green this.GetModule<Hue>().ApplyHueConfigration("Film du soir"); break; case "E0E0A857": // Yellow this.GetModule<Hue>().ApplyHueConfigration("Cheminée"); break; case "E0E06897": // Blue this.GetModule<Hue>().ApplyHueConfigration("Tout éteind"); break; |
Pour appliquer une configuration, je récupère dans le JSON l’état de chaque lampe à partir du nom de la configuration à appliquer. Pour chaque lampe, j’envoie un message “Set” au package Hue avec la couleur (Hue + Sat) et l’intensité (bri) de lampe (identifiée par son “id”) :
1 2 3 4 | foreach (dynamic hue in config.Lights) { this.SendMessage("Hue").Set(hue.id, hue.state, hue.hue, hue.sat, hue.bri); } |
Démonstration :
Pour le contrôle du thermostat Nest, les touches “<<” et “>>” diminue ou augmente la température de consigne de 0,5°C et la touche “Rec” défini la température à 20°C :
1 2 3 4 5 6 7 8 9 | case "E0E0A25D": // Step down this.SendMessage("Nest").SetTargetTemperature(Convert.ToDouble((string)this.Nest.DynamicValue.target_temperature_c) - 0.5); break; case "E0E012ED": // Step up this.SendMessage("Nest").SetTargetTemperature(Convert.ToDouble((string)this.Nest.DynamicValue.target_temperature_c) + 0.5); break; case "E0E0926D": // Rec this.SendMessage("Nest").SetTargetTemperature(20); break; |
Pour connaitre la température de consigne courante (target_temperature_c), il suffit de créer un StateObjectLink vers le StateObject du Nest :
1 2 | [StateObjectLink("Nest", "Living Room")] public StateObjectNotifier Nest { get; set; } |
Pour le contrôle Kodi, certain me diront qu’il est déjà possible de contrôler son media-center Kodi installé sur un Rasberry PI avec la télécommande de la TV grâce au protocole CEC.
Seulement dans mon cas Kodi n’est pas installé sur un Raspberry mais sur un Intel NUC qui ne gère pas le CEC. De plus, mon media-center n’est pas directement connecté sur la TV mais sur l’ampli Home Cinéma ce qui bloque le CEC.
Bref dans cette architecture, impossible de piloter Kodi avec la télécommande la TV. Cependant comme Kodi est connecté dans Constellation, il est possible de le contrôler !
Pour cela, j’envoie des messages au package Xbmc pour contrôler la lecture et/ou la navigation depuis les codes IR de la télécommande. Par exemple :
1 2 3 4 5 6 7 8 9 10 11 | case "E0E052AD": // Pause case "E0E0E21D": // Play this.SendMessage("Xbmc").PlayPause("XBMC Salon"); break; case "E0E0629D": // Stop this.SendMessage("Xbmc").Stop("XBMC Salon"); break; case "E0E01AE5": // return this.SendMessage("Xbmc").SendInputKey("XBMC Salon", InputKey.Back); break; // etc... |
Ainsi un appui sur une des touches de navigation de la télécommande sera capté par l’ESP. Il enverra un message “SignalReceive” contenant le code du signal décodé. Le message sera reçu le package “MyBrain” qui enverra un message au package Xbmc/Kodi, lui-même en relation avec le service HTTP du Kodi sur mon Intel NUC !
Bref, je contrôle également mon media-center Kodi sur Intel NUC avec les touches de ma télécommande de TV Le chemin est juste un peu plus long, mais le temps de réaction est immédiat !
Chose intéressante avec Kodi connecté dans Constellation (autre que la possibilité de le contrôler) est qu’il est possible de connaitre son état (le media en cours de lecture, son statuts, etc…) comme utilisé dans S-Panel ou par mon package MyBrain pour adapter automatiquement les lumières du salon lorsqu’on lance un film ou une série.
De plus le package permet également d’afficher des notifications. Par exemple dès lors que la température du chauffage Nest est modifiée, une notification est envoyée sur tous les Kodi de la maison (très pratique pour avoir confirmation visuelle lorsque l’on modifie la température avec la télécommande).
Cela se réalise en 3 lignes de code C# en s’abonnant à la mise à jour du StateObject du Nest :
1 2 3 4 5 6 7 | this.Nest.ValueChanged += (s, e) => { if (e.OldState.DynamicValue.target_temperature_c != e.NewState.DynamicValue.target_temperature_c) { this.SendMessage("Xbmc").ShowNotification(new { Title = "Thermostat", Message = "Temperature de consigne: " + (string)e.NewState.DynamicValue.target_temperature_c + "°C", Image = "info") }); } }; |
Conclusion
Comme vous avez pu le découvrir dans cet article, les ESP8266 permettent de créer tout type d’objet connecté. Grâce à leur connectivité Wifi, ces microcontrôleurs peuvent être directement connectés sur l’API REST de Constellation et échanger des messages avec les autres systèmes, produire des StateObjects ou réagir aux StateObjects des autres packages de la Constellation.
Les possibilités sont immenses.
Ici, nous avons utilisé une simple LED et un récepteur infrarouge pour réaliser une passerelle IR permettant à tout système connecté dans votre Constellation, que ce soit une application Windows, un script Python sur Raspberry, un prototype Arduino ou Gadgeteer, une page Web, une application mobile, etc … d’envoyer mais également de recevoir des signaux infrarouges grâce à la plateforme Constellation.
On a pu ainsi réaliser une application de type “télécommande universelle” en 10 lignes de code JavaScript et se servir de notre télécommande IR pour contrôler tout type de chose, comme une scène 3D avec le moteur BabylonJS ou les différents objets connectés de la maison.
Personnellement, j’ai redécouvert le potentiel de la télécommande de ma TV afin pouvoir contrôler mon Kodi/Xbmc, le chauffage et tous les luminaires du RDC. C’est un contrôleur très pratique, à portée de main, intuitif et réactif.
Pour moins de 10€ de matériel et avec la plateforme Constellation, vous pouvez réaliser une passerelle IR très polyvalente.
La seule limite sera votre imagination
Dodutils
Combien de temps il a fallu pour rédiger ce billet bien détaillé ?
Sebastien
C’est une bonne question 😉 J’écris mes articles par fragment… 1 heure par ci, deux heures par là, en fonction de mes dispos, inspiration et motivation 🙂
Hydro
Excellent article 🙂 J’étais en train de voir pour ajouter un module CEC à ma TV mais je vais peut être retenir cette idée.
Question bête, c’est possible d’avoir plusieurs led émetteurs sur un esp ? J’ai plusieurs enceintes placées à des endroits différents et j’aimerais les contrôler depuis un seul point.
Sebastien
Moi aussi je pensais mettre un module CEC/USB, mais c’est seulement en connectant ma passerelle IR à Constellation que je me suis dis « mais j’ai accès à XBMC »…. De ce fait, le module CEC n’a plus d’intérêt 🙂
Oui tu pourrais mettre plusieurs LED pour l’émission, orientées différemment ou bien comme dans mon cas (TV de la chambre & du salon) : avoir plusieurs passerelles ! Pour 10€ c’est pas déconnant d’en installer plusieurs ! Versus l’ « IRtrans Ethernet » à 145€ (http://my-domotique.com/store/396-irtrans-ethernet-ir.html) il n’y a pas photo 🙂
Hydro
Mais du coup est ce que tu gères les sources aussi avec ? Moi par exemple je switch souvent entre mon htpc et ma freebox, sauf que la télécommande n’a pas de bouton pour chaque source.
Du coup faudrait implanté une variable qui se souvient sur quelle source je me places à chaque fois.
Dodutils
C’est marrant je suis justement en train de modifier mes vieilles (mais toujours excellentes) enceintes 2.0 Altec Lansig pour leur ajouter un module de contrôle infra-rouge pour piloter les 2 boutons physiques (Volume + et Volume – et les deux simultanément pour faire on/off) via des boutons inutilisés de ma télécommande TV le tout de façon invisible installé à l’intérieur de l’enceinte enfin sauf pour la diode de réception IR pour laquelle je ferai un petit trou propre pour la faire ressortir 🙂
Sebastien
@Hydro : je triche un peu ! Comme expliqué à la fin de cet article, toutes mes sources HDMI sont reliées à mon ampli Pioneer lui même relié à la TV en HDMI !
Au niveau de la TV, il n’y a qu’une seule source : l’HDMI de l’ampli et ne change jamais !
Le « switch » des sources se fait donc sur mon ampli Pioneer !
Il y a deux ans, j’ai réussi à mettre la main sur des documentations de Pioneer détaillant le protocole réseau ! J’ai donc pu écrire un package Constellation qui pilote et remonte l’état de l’ampli : écran LCD, inputs, volume, tuner FM et Web radio, etc.. etc… Bref, le contrôle total de l’ampli sur Constellation !
De ce fait, pour changer de source, il suffira d’envoyer un message à ce package avec le nom de l’entrée à sélectionner ! (D’ailleurs, dans l’interface S-Panel tu trouveras le contrôle de l’ampli : https://sebastien.warin.fr/2015/07/15/3033-s-panel-une-interface-domotique-et-iot-multi-plateforme-avec-cordova-angularjs-et-constellation-ou-comment-crer-son-dashboard-domotique-mural/)
Franck
Excellent article. Merci.
Ça donne vraiment envie d’essayer constellation dont j’entends parler depuis si longtemps.
Daniel
super article comme toujours très intéressant et plein de bonnes idées mais a quand une release de la constellation car ce serait cool de lier la théorie.. a la pratique 😉
Hervé
Bonjour,
Encore un article très intéressant (comme toujours), mais l’élément central reste « constellation » que l’on ne peut pas atteindre. J’ai lu tous tes articles, j’ai toutes les revues dans lesquelles tu as écrit, j’ai bricolé quelques montages mais que peut-on faire d’autre ?
J’ai déjà demandé à plusieurs reprises l’accès à la plateforme Constellation toutes restées sans réponse, pourquoi ?
Il y a un bon mois tu écrivais en réponse à l’article consacré au « Home Analytic (Kibana, …) » que tu étais sur le point de faire partir un msg nous expliquant le pourquoi du non accès à constellation, que l’attente avait assez duré. Sauf erreur de ma part je n’ai rien vu passer concernant ce point.
Tout ceci n’enlève rien à la qualité de tes articles que je dévore dés leur sortie, mais des news concernant la disponibilité de constellation seraient très appréciées. Je ne désespère pas car Noël arrivant à grand pas, je suis quasiment sur que le père noël aura une constellation dans sa hôte… ou à défaut un message de ta part….
Cordialement, RV.
Hector
Bonjour,
Qu’est-ce qui bloque la release de Constellation ? de la doc ? les packages NuGet ? On peut aider ?
Cordialement, Hector
Hervé
Sebastien, bonjour,
Dans ton article de la revue programmez tu parles d’un « tool chain » permettant d’utiliser notre cher Visual Studio pour attaquer les puces ESP8266. J’avoue être un peu perdu sur ce qu’il faut installer pour arriver à cela, entre l’installation de « esp8266-gcc5.2.0-r4.exe » ou une installation manuelle tel que décrit « http://www.esp8266.com/wiki/doku.php?id=setup-windows-compiler-esp8266 » ou encore l’utilisation du plugin VisualGDB (que tu sites) mais qui semble payant. Peux-tu nous apporter une aide là dessus, nous faire un retour sur le minimum à installer ?
Cordialement, RV
Hydro
Bonjour, un petit retour sur le DD2015 bientôt ? Et sur constellation peut être avant la fin de l’année ?
Renaud
Bonjour à tous,
C’est marrant, j’étais justement en train de penser à la même chose : ce serait un beau cadeau de Noël, cette constellation…
A très bientôt.
Hydro
Papa Noël est pas passé ;(
Sebastien
Le père Noel vient de passer… un peu en retard mais il est bien passé dans vos boites aux lettres 🙂
marc
pas chez moi
marc
yes ! Thanks
Sebastien
Le temps de passer la frontière belge 😉
Jonathan
Je n’ai rien recu dans ma boîte au lettre. Est-ce que tu peux me l’envoyé ?
xeys
Bonjour,
moi non plus rien ;(
Est-ce possible d’avoir un petit accès ? 🙂
Emilien
Bonjour Sébastien,
j’avais pris contact en passant par le site http://www.myconstellation.io/ il y a quelques temps.
Visiblement, je ne suis pas non plus dans la boucle.
Est-ce possible d’y être 🙂 ?
Christophe
Bonjour, est-il possible de me rajouter dans votre mailing list afin de recevoir les infos sur constellation ? Un grand merci d’avance
Manumil
Bonjour Sebastien,
Je me suis aussi inscrit pour recevoir le cadeau du pere noel , mais au cas ou, je lui fait un petit appel du pied ici … 😉
Bonne année a tous
Luc
Idem, j’avais poster une demande de contact sur le site myconstellation.io suite a nos discution sur le groupe du WAF, mais toujours rien. :'(
Yann
Bonjour,
Pouvez-vous aussi me rajouter dans votre mailing list.
Merci d’avance.
Sebastien
Bonjour,
Je suis également très intéressé par Constellation, si vous pouviez m’ajouter a votre liste de diffusion.
Merci
Daniel
idem pour moi. mail laissé à 2 ou 3 reprises et pas eu de passage du pere noel 🙁
j’espere que le pere sebastien Noel pensera à moi rapidement 🙂
Npster57
Bonjour,
Petit commentaire pour vous féliciter sur la qualité de vos articles toujours bien expliqués, c’est appréciable! Votre solution domotique est assez complète et originale (habitué aux montages raspberry/arduino), dommage qu’il n’y a ai pas plus d’informations sur Constellation!)
Je me joins à la mailing list si vous voulez bien m’y ajouter afin d’en découvrir plus sur Constellation!
PS: Bravo pour la détection avec camera du compteur, ca change des montage optocoupleurs / Ne555^^
Cordialement
Cyril
Bonjour,
Félicitations pour votre blog très instructif.
Je vous ai laissé quelques messages, serait-il possible d’être mis sur la liste de diffusion de constellation ? J’aimerai beaucoup tester ce système pour mon appartement.
Merci beaucoup.
Jean-Baptiste
Bonjour,
J’ai lu tout vos posts concernant constellation. C’est impressionnant et ça donne envie …
Je crois que nous attendons tous avec impatience l’ouverture de cette solution domotique.
Pouvez vous nous donner des nouvelles ?!
En tout cas BRAVO !
Jeremy
Bonsoir,
Bravo pour le travail accompli ! J’aimerai, comme beaucoup, savoir si il est possible d’être sur la liste de diffusion de la version beta privée ?
Merci beaucoup.
jerome
Bonjour,
Je me suis inscrit sur le site myconstellation.io il y a quelques temps pour faire partie des heureux privilègiés beta testeurs de constellation mais je n’ai malheuresement pas de mail pour le moment, du coup je me permet ce petit com pour demander à être rajouté à la liste de diffusion.
Merci et continue tes articles toujours aussi passionnants.
Philippe
Bonjour,
Félicitations pour cet excellent travail. J’essai aussi de me mettre à la domotique mais comme beaucoup les débuts sont difficiles. Mon idée serait de contrôler aussi mes radiateurs électriques en fonction de la présence, etc. Un peu dans l’idée de ce que propose Aterno où en plus sophistiqué Nest.
Trackback: Découverte des ESP8266 : le microcontrôleur connecté par Wifi pour 2€ au potentiel phénoménal avec Constellation - Sebastien.warin.fr
ktrianta
sebastien Hi,
my goal is to control 10-15 same brands tvs just using Domoticz (Rasperry pi) and 10-15 ESP 8266 with ir transmiter on it (one for each TV)
your solution is very close but i need some help.
i am willing to donate for the solution!
Trackback: S-DoorBell : connecter sa sonnette à Constellation avec un ESP8266 ou comment protéger le sommeil de son enfant, la sonnette propulsée dans Constellation ! - Sebastien.warin.fr
laurent
Bonjour,
Merci pour votre tuto qui est super bien.
J’ai juste un problème avec l’envoi de code pour une télécommande Samsung car le lorsque je met une trace sur le port série, le code envoyé par la page web et celui décodé ne correspond pas du tout.
J’ai portant modifié le irsend.sendNEC en irsend.sendSamsung et mis le codage sur 32 bit au lieu de 36 !!
je pense qu’il y a autre chose a modifier, mais la je sèche !!!
Avez-vous une idée..