Démarrer avec le développement IoT : un didacticiel Arduino ESP8266

L'objectif de ce didacticiel Arduino ESP8266 est de se familiariser avec la programmation embarquée avec Arduino sur une puce devenue très populaire parmi la communauté des fabricants (et les développeurs en général) pour son accessibilité et sa facilité d'utilisation dans l'espace IoT. Le didacticiel nous salit également les mains avec Alexa en utilisant un "hack" non officiel pour qu'Alexa fasse nos enchères à la maison (cette technique n'est pas destinée à être utilisée en production, uniquement pour une démonstration à domicile). Essayez ceci à la maison, mais pas au travail.

La beauté de cette technique est que nous pouvons l'utiliser dans nos propres maisons pour qu'Alexa automatise presque littéralement tout ce qui fonctionne à l'électricité. En prime, nous avons un aperçu de la programmation embarquée avec Arduino, une compétence qui n'est peut-être pas si courante chez les programmeurs traditionnels de nos jours. Enfin, nous nous mettons au travail avec la populaire puce ESP8266, préférée des bricoleurs ; c'est une petite puce étonnante capable d'exécuter toutes sortes de choses, avec une puce Wifi intégrée dont nous aurons besoin pour ce projet. C'est ce qui permettra à l'appareil Alexa et à la puce de communiquer directement entre eux.

Quelques informations sur la programmation Alexa : le modèle de programmation "compétences" d'Alexa fonctionne comme suit :

• Vous parlez à votre Alexa.
• Alexa achemine votre discours jusqu'au cloud d'Amazon.
• La commande vocale est acheminée vers une "compétence" Alexa (un programme qui s'exécute dans le cloud d'Amazon).

La « compétence » Alexa prend en charge la gestion de la commande ; normalement, une réponse est renvoyée à l'appareil Alexa, l'amenant à dire quelque chose à l'utilisateur en réponse. Dans le cas d'Alexa IoT, la commande est acheminée vers un "appareil fantôme" sur le cloud d'Amazon, ce qui entraîne finalement l'envoi d'une réponse à un autre appareil de votre maison. Nous contournons tout cela avec notre hack. Nous voulons que l'appareil Alexa parle directement à notre puce ESP8266, à l'intérieur de notre maison, sans rien envoyer vers le cloud et en revenir. Nous voulons qu'Alexa envoie directement une demande à notre ESP8266, sur et à l'intérieur de notre réseau Wi-Fi domestique uniquement.

Notre hack n'est pas vraiment un secret. Nous allons faire en sorte que notre ESP8266 "émule" un Wemo Belkin, un appareil qui a une licence spéciale avec Amazon lui permettant de communiquer directement avec l'appareil Alexa, en contournant toute cette communication cloud Amazon décrite ci-dessus.

Se faisant passer pour un Wemo, notre ESP8266 bénéficie du privilège de pouvoir recevoir des commandes directement de l'Alexa.

Plan de base pour notre tutoriel Arduino ESP8266

• Écoutez sur l'ESP8266 si l'appareil Alexa envoie des sondes sur le réseau Wi-Fi local pour les appareils compatibles, et répondez à ces sondes en disant "Je suis un Wemo".
• Une fois approuvé par l'appareil Alexa, écoutez d'autres commandes dudit appareil. Gérez-les en envoyant des codes IR via l'émetteur IR, en allumant/éteignant notre téléviseur.

Exigences matérielles

Pour terminer ce didacticiel, vous devrez vous procurer vous-même certains éléments, qui sont tous faciles à obtenir.

• N'importe quel appareil Alexa. J'ai développé ce tutoriel avec un Alexa Dot. Le tutoriel fonctionnera-t-il avec un simulateur Echo ? Ça pourrait ! (Mais je ne l'ai pas testé). Essayez-le si vous vous sentez aventureux (ou frugal). L'appareil Alexa coûte de l'argent de poche, mais l'utilisation de l'Echosim est gratuite.
• Une puce ESP8266. Ils ne coûtent que quelques USD au moment d'écrire ces lignes. Vous pouvez les obtenir sur Ebay, ou à peu près n'importe quel magasin de matériel bien approvisionné en ligne.
• Une diode IR (infrarouge). Vous devrez le câbler à votre puce ESP8266, et vous devrez le faire vous-même. Pour ce projet, nous n'avons besoin que des capacités d'envoi ; nous ne nous soucions pas de la réception IR. Assurez-vous de câbler la diode à GND et de sortir 0 pour que ce tutoriel fonctionne. (Si vous le faites d'une autre manière, c'est bien, mais vous devrez également être responsable de la modification du code du didacticiel en conséquence. Ce lien peut vous aider. Sachez qu'en raison du schéma de numérotation utilisé sur l'ESP8266, broche 0 peut être étiqueté comme "D3".
• Un adaptateur série qui d'un côté est USB (à brancher sur votre ordinateur de développement), et l'autre côté s'insère dans la puce ESP8266.
• Un réseau wifi local dont vous connaissez le nom d'utilisateur et le mot de passe.

Outils logiciels Arduino

• IDE Arduino. Il existe des versions pour tous les principaux systèmes d'exploitation, y compris Windows. Ce tutoriel a été développé sur la version Ubuntu, mais j'ai également installé et utilisé Arduino sur Windows, sans aucun problème.
• La bibliothèque de développement ESP8266 pour Arduino.
• Conducteurs. Heureusement, les pilotes de votre adaptateur devraient très probablement être plug & play, donc aucun pilote supplémentaire n'est requis.

Tout configurer

• Installez l'IDE Arduino.
• Installez la bibliothèque ESP8266 à l'aide de Boards Manager.

Pour installer la bibliothèque ESP8266 à l'aide de Boards Manager :

• Dans l'IDE Arduino, ouvrez File -> Preferences .
• Entrez cette URL dans "Additional Boards Manager URL": http://arduino.esp8266.com/stable/package_esp8266com_index.json
• Cliquez sur OK

• Accédez au Gestionnaire de tableaux ( Outils -> Tableau : [tableau actuel] -> Gestionnaire de tableaux ).

• Dans la zone de texte "filtre", tapez "ESP8266".
• Vous devriez obtenir une entrée pour "esp8266" maintenant que vous avez ajouté le gestionnaire de cartes supplémentaires. Choisissez-le et cliquez sur "installer".

• Attendez un peu, il faut un certain temps pour tout télécharger.
• Redémarrez votre IDE Arduino.
• Ouvrez Outils -> Carte : et, cette fois, faites défiler jusqu'à "Module générique ESP8266" et sélectionnez-le.

Ajout de bibliothèques tierces

Arduino propose de nombreuses façons d'ajouter des bibliothèques externes à votre projet, ou "Sketch", comme ils l'appellent. Afin de simplifier au maximum les choses, pour ce tutoriel, nous prendrons juste le plus rapide à expliquer, qui consiste simplement à copier des dossiers. Nous devrons ajouter exactement deux bibliothèques externes pour que le tutoriel fonctionne : IRemoteESP8266 et https://github.com/me-no-dev/ESPAsyncTCP.

• Dans le code du tutoriel dans GitHub, recherchez le répertoire "libraries".
• Dans le répertoire d'installation racine d'Arduino (par exemple, C:\Program Files\Arduino), recherchez le sous-répertoire "libraries".
• Copiez le répertoire IRemoteESP8266 du répertoire "libraries" du tutoriel dans le répertoire "libraries" d'Arduino.
• Copiez le répertoire ESPAsyncTCP du répertoire "libraries" du tutoriel dans le répertoire "libraries" d'Arduino.
• Redémarrez l'IDE Arduino.

Maintenant, les bibliothèques pour la transmission IR et TCP asynchrone sont incluses dans le projet.

Réglages

L'image ci-dessous montre les paramètres typiques, qui fonctionnent pour moi et mon matériel, mais peuvent varier pour chaque utilisateur. Vous pouvez essayer les paramètres ci-dessous, mais il est possible que vous deviez les ajuster en fonction de votre puce et de votre adaptateur. Le mien est nodemcu, par exemple, j'ai donc dû changer la méthode de réinitialisation de "ck" (la valeur par défaut) à "nodemcu". Définissez également "port de débogage" sur "série" afin de pouvoir utiliser le débogueur série. La mienne est une configuration très typique, vous pouvez donc utiliser mes paramètres comme base ; Je dis juste ne soyez pas surpris si vous devez jouer avec eux pour que le processus de compilation et de flash fonctionne.

Prouvez votre configuration avec un ESP8266 Hello World

Les projets Arduino commencent par un fichier .ino. Le fichier .ino définit deux points d'entrée : configuration et boucle. Pour notre "hello world", on va allumer une petite lumière, sur l'ESP8266, histoire de vérifier que notre code fonctionne.

 //SET TO MATCH YOUR HARDWARE #define SERIAL_BAUD_RATE 9600 #define LED_PIN 2 /*---------------------------------------*/ //Runs once, when device is powered on or code has just been flashed void setup() { //if set wrong, your serial debugger will not be readable Serial.begin(SERIAL_BAUD_RATE); pinMode(LED_PIN, OUTPUT); } /*---------------------------------------*/ //Runs constantly void loop() { digitalWrite(LED_PIN, LOW); delay(1000); digitalWrite(LED_PIN, HIGH); delay(1000); }

Compiler et flasher le code

Compiler et flasher sont des étapes faciles, si votre configuration jusqu'à présent est correcte. Pour compiler sans clignoter, allez simplement dans Sketch -> Verify/Compile depuis le menu Arduino.

Pour flasher le code sur la puce ainsi que compiler, sélectionnez Sketch -> Upload dans le menu Arduino.

Si le flash réussit, vous verrez un affichage de progression passer de 0% à 100%, période pendant laquelle la LED de votre puce clignotera ou clignotera très probablement.

Pour tester que le débogage série fonctionne :

• Assurez-vous d'abord que le port de débogage est défini sur Série ( Outils -> Port de débogage ).
• Une fois que votre code a fini de clignoter sur la puce, sélectionnez Outils -> Serial Monitor .

Sortie du débogueur série après un démarrage réussi :

Super, donc ça marche ; ensuite, nous voulons vérifier notre sortie IR. Envoyons un signal via notre émetteur IR et vérifions que le signal passe.

Nous allons utiliser une bibliothèque IR Arduino existante pour nous aider. L'un des grands avantages d'Arduino est la facilité avec laquelle il est possible d'insérer et de retirer des bibliothèques et des modules. Très rafraîchissant pour un framework C++ !

Suivez simplement les instructions du fichier README de ce référentiel Git pour l'installer dans Arduino.

Ce code fait simplement clignoter l'émetteur IR à plusieurs reprises. L'IR est invisible à l'œil humain, mais il existe un conseil de pro pour le tester ; exécutez ce code, vérifiez (via le débogueur) qu'il s'exécute sur votre puce, puis ouvrez l'appareil photo de votre appareil mobile. Regardez directement l'ampoule à diode IR à travers votre appareil photo . Si cela fonctionne, vous devriez voir l'ampoule s'allumer et s'éteindre visiblement. Vous pouvez également essayer cela avec n'importe quelle télécommande en état de marche (par exemple, une télécommande de téléviseur standard). Le code suivant devrait faire clignoter l'ampoule IR toutes les 0,5 seconde. En fait, il envoie la commande marche/arrêt LG, de sorte qu'il peut en fait éteindre et rallumer votre téléviseur LG s'il se trouve à proximité.

 #include <IRremoteESP8266.h> // IR Library IRsend* irSend; // infrared sender //SET TO MATCH YOUR HARDWARE #define SERIAL_BAUD_RATE 9600 //PIN 0 is D3 ON THE CHIP #define IR_PIN 0 /*---------------------------------------*/ //Runs once, when device is powered on or code has just been flashed void setup() { //if set wrong, your serial debugger will not be readable Serial.begin(SERIAL_BAUD_RATE); //initialize the IR irSend = new IRsend(IR_PIN, true); irSend->begin(); } /*---------------------------------------*/ //Runs constantly void loop() { irSend->sendNEC(0x20DF10EF, 32, 3); delay(1000); }

Commencer le didacticiel ESP8266

Si tout a fonctionné jusqu'à présent, je pense que nous pouvons être satisfaits que notre équipement et notre configuration de base fonctionnent, et nous sommes prêts à commencer la viande du didacticiel.

Connectez-vous au Wi-Fi

Tout d'abord, nous allons devoir nous connecter au wifi local. Le code ci-dessous tentera de se connecter au Wifi et signalera le succès de la connexion (via le débogueur série). Dans l'exemple de code, n'oubliez pas de remplacer la valeur de myWifiSsid par le nom d'utilisateur de votre réseau wifi et de remplacer la valeur de myWifiPassword par le mot de passe correct.

 #include "debug.h" // Serial debugger printing #include "WifiConnection.h" // Wifi connection // this file is part of my tutorial code #include <IRremoteESP8266.h> // IR library WifiConnection* wifi; // wifi connection IRsend* irSend; // infrared sender //SET YOUR WIFI CREDS const char* myWifiSs; const char* myWifiPassword = "*******"; //SET TO MATCH YOUR HARDWARE #define SERIAL_BAUD_RATE 9600 //PIN 0 is D3 ON THE CHIP #define IR_PIN 0 /*---------------------------------------*/ //Runs once, when device is powered on or code has just been flashed void setup() { //if set wrong, your serial debugger will not be readable Serial.begin(SERIAL_BAUD_RATE); //initialize wifi connection wifi = new WifiConnection(myWifiSsid, myWifiPassword); wifi->begin(); //connect to wifi if (wifi->connect()) { debugPrint("Wifi Connected"); } } /*---------------------------------------*/ //Runs constantly void loop() { }

Exécutez le serveur Wemo

Lié? Bien. Nous arrivons maintenant au coeur du projet : le serveur Wemo.

Mon propre émulateur Wemo est inclus dans les fichiers source de ce tutoriel. Maintenant, vous pouvez rechercher sur Google et trouver un émulateur Wemo plus simple. Vous pouvez en trouver un écrit avec moins de code et facile à comprendre. Par tous les moyens, n'hésitez pas à examiner, expérimenter, écrire le vôtre, etc. Tout cela fait partie de l'appropriation de ce didacticiel.

Le raisonnement derrière le mien est qu'il utilise ESPAsyncTCP. Pourquoi est-ce bon ? Eh bien, il n'y a qu'un nombre limité de serveurs (ou d'appareils) que vous pouvez exécuter sur l'ESP8266 en utilisant cette méthode avant qu'il ne commence à devenir peu fiable, dans le sens où Alexa commencera à manquer des appareils (ne les trouvant pas), les commandes seront supprimées et les performances devient lent. Je trouve que ce nombre est maximisé par l'utilisation de la bibliothèque ESPAsyncTCP.

Sans cela, j'ai constaté que le manque de fiabilité s'insinuait sur environ 10 à 12 appareils ; avec elle, je trouve que ce nombre monte à environ 16. Au cas où vous voudriez étendre ce tutoriel et explorer les limites de ce que la puce peut faire, je vous recommande d'utiliser ma version. Si vous voulez voir une version plus simple juste pour votre propre compréhension, n'hésitez pas à rechercher « wemo émulateur Arduino » sur Google ; vous devriez trouver une foule d'exemples.

Maintenant, nous devons installer la bibliothèque ESPAsyncTCP. Installez-le comme nous l'avons fait pour la bibliothèque IR ; allez sur la page Git et suivez les instructions.

Cette bibliothèque est également incluse dans mon exemple de code arduino esp8266. Voici juste le code pour ouvrir la connexion wifi, écouter la demande de découverte d'Alexa et la gérer en renvoyant une réponse "Je suis Wemo".

 #include "debug.h" // Serial debugger printing #include "WifiConnection.h" // Wifi connection #include "Wemulator.h" // Our Wemo emulator #include <IRremoteESP8266.h> // IR library WifiConnection* wifi; // wifi connection Wemulator* wemulator; // wemo emulator IRsend* irSend; // infrared sender //SET YOUR WIFI CREDS const char* myWifiSs; const char* myWifiPassword = "*******"; //SET TO MATCH YOUR HARDWARE #define SERIAL_BAUD_RATE 9600 //PIN 0 is D3 ON THE CHIP #define IR_PIN 0 /*---------------------------------------*/ //Runs once, when device is powered on or code has just been flashed void setup() { //if set wrong, your serial debugger will not be readable Serial.begin(SERIAL_BAUD_RATE); //initialize wifi connection wifi = new WifiConnection(myWifiSsid, myWifiPassword); wifi->begin(); //initialize the IR irSend = new IRsend(IR_PIN, false); irSend->begin(); //initialize wemo emulator wemulator = new Wemulator(); //connect to wifi if (wifi->connect()) { wemulator->begin(); //start the wemo emulator (it runs as a series of webservers) wemulator->addDevice("tv", new WemoCallbackHandler(&commandReceived)); wemulator->addDevice("television", new WemoCallbackHandler(&commandReceived)); wemulator->addDevice("my tv", new WemoCallbackHandler(&commandReceived)); wemulator->addDevice("my television", new WemoCallbackHandler(&commandReceived)); } } /*---------------------------------------*/ //Runs constantly void loop() { //let the wemulator listen for voice commands if (wifi->isConnected) { wemulator->listen(); } }

Pré-test

Testez ce que nous avons jusqu'à présent (wifi et émulateur), en l'exécutant avec Alexa. Ce didacticiel suppose que votre appareil Alexa est configuré et installé chez vous.

Tester la découverte :

Dites à Alexa : « Alexa, découvre des appareils ».

Cela amènera Alexa à diffuser une demande UDP sur votre réseau Wi-Fi local, en recherchant Wemos et d'autres appareils compatibles. Cette requête doit être reçue dans l'appel à wemulator->listen(); dans la fonction loop(). Cela l'achemine à son tour vers la méthode handleUDPPacket(*) de Wemulator. Une réponse est envoyée dans la méthode nextUDPResponse() . Notez le contenu de cette réponse :

 const char UDP_TEMPLATE[] PROGMEM = "HTTP/1.1 200 OK\r\n" "CACHE-CONTROL: max-age=86400\r\n" "DATE: Sun, 20 Nov 2016 00:00:00 GMT\r\n" "EXT:\r\n" "LOCATION: http://%s:%d/setup.xml\r\n" "OPT: \"http://schemas.upnp.org/upnp/1/0/\"; ns=01\r\n" "01-NLS: %s\r\n" "SERVER: Unspecified, UPnP/1.0, Unspecified\r\n" "ST: urn:Belkin:device:**\r\n" "USN: uuid:Socket-1_0-%s::urn:Belkin:device:**\r\n\r\n";

C'est le code qui dit à Alexa "Je suis un Wemo (Belkin), comment puis-je vous aider?" Une fois qu'Alexa reçoit cette réponse, elle sait et se souvient que les futures commandes de maison intelligente peuvent être acheminées vers cet appareil.

La sortie du débogueur série à ce stade devrait ressembler à l'image ci-dessous. Une fois la découverte terminée, Alexa vous dira verbalement qu'elle a "découvert [N] appareils" sur votre réseau.

Dans la fonction setup() , notez l'extrait suivant :

 new WemoCallbackHandler(&commandReceived)

C'est le rappel où nous allons capturer les commandes d'Alexa. Son corps est défini dans WemoCallbackHandler.h (WemoCallbackHandler::handleCallback). Une fois que nous avons capturé une commande d'Alexa, nous pouvons en faire ce que nous voulons. Dans les lignes précédentes, nous avons défini les commandes possibles pouvant être utilisées, avec ces lignes de code :

 wemulator->addDevice("tv"); wemulator->addDevice("television"); wemulator->addDevice("my tv"); wemulator->addDevice("my television");

Ce sont donc 4 "serveurs" ou écouteurs distincts que nous exécutons sur la puce. Cela configure la possibilité de dire l'une des commandes suivantes à Alexa :

Alexa, allume la télé Alexa, éteins la télé Alexa, allume la télévision Alexa, éteins la télévision Alexa, allume ma télé Alexa, éteins ma télé Alexa, éteins ma télévision Alexa, éteins ma télévision

Et voici comment nous allons le tester. Nous nous attendons à ce que dire l'une de ces commandes réveille notre code et entre ce rappel, où nous pouvons en faire ce que nous voulons.

Ajouter la commande IR

Maintenant que nous recevons la commande, il est temps de la gérer en… allumant/éteignant notre téléviseur. Ce sera donc tout - wifi, émulateur wemo et IR - tous réunis. Mon téléviseur est un LG, j'ai donc recherché la séquence appropriée pour allumer / éteindre, et je l'ai envoyée via la fonction sendNEC de notre bibliothèque IR (LG utilise le protocole NEC). Le codage/décodage IR est un sujet distinct en soi, dans lequel un message est codé dans la modulation d'un signal ; c'est une spécification de timings, de marques et d'espaces très précis. Chaque fabricant a tendance à utiliser son propre protocole propriétaire pour les commandes, et avec des timings différents ; c'est assez intéressant, et vous pouvez creuser plus profondément en regardant dans le code source de cette bibliothèque IR, en cherchant sur Google, etc. Mais à notre convenance, les détails de tout ce qui est pris en charge pour nous par notre bibliothèque IR.

Votre téléviseur n'est pas un LG ? Il suffit de googler le bon code. Voici la commande pour les téléviseurs Sony (mise en garde : non testée) :

 irSend.sendSony(0xa90, 12);

Si vous voulez vraiment faire du bricolage, vous pouvez configurer un récepteur infrarouge, pointer votre télécommande (ou n'importe quel émetteur infrarouge) vers celui-ci et décoder les codes qu'il envoie ; c'est un tutoriel différent, cependant.

Essai de bout en bout

• Placez votre Alexa partout où elle peut vous entendre.
• Placez votre ESP8266 avec la diode IR attachée, à portée de la télécommande du téléviseur.
• Dites « Alexa, découvre les appareils ». Attendez qu'il signale le succès (il devrait avoir découvert au moins un appareil).
• Dites « Alexa, allume mon téléviseur » ou « Alexa, éteins mon téléviseur ».

Alexa doit comprendre votre commande (comme une commande smarthome, non dirigée vers une compétence spécifique), rechercher un appareil local pour la gérer et envoyer la commande à l'appareil (votre ESP8266). Votre appareil devrait le recevoir et envoyer la commande de la télécommande au téléviseur. Vous pouvez voir votre diode à travers une caméra de téléphone portable pour vous assurer qu'elle émet.

Étant donné que le code IR pour éteindre un téléviseur est le même que le code pour l'allumer, peu importe que vous donniez la commande d'allumer ou d'éteindre. C'est le même code, et il bascule l'état. Si le téléviseur est éteint, il doit s'allumer, et s'il est allumé, il doit s'éteindre.

Dépannage

Êtes-vous connecté au Wifi ?

Avez-vous entré le nom d'utilisateur/mot de passe correct dans les valeurs de variables correctes ?

 //SET YOUR WIFI CREDS const char* myWifiSs; const char* myWifiPassword = "*******";

Recevez-vous un message d'échec ou une erreur via le port de débogage série lors de la connexion au Wifi ?

Votre Wifi est-il allumé et pouvez-vous vous y connecter par tout autre moyen ordinaire ?

Votre appareil est-il découvert par Alexa ?

Alexa enverra des demandes de découverte d'appareils lorsque vous direz "Alexa, découvre des appareils".

Votre Alexa doit être configurée et configurée correctement et connectée au même réseau Wifi que votre ESP8266.

Regardez dans Fauxmo.h. Voir la fonction Fauxmo::handle(). C'est le premier code qui s'exécutera une fois que l'ESP8266 aura entendu l'appel. Mettez des messages de débogage pour voir si un code après

 if (len > 0) {

est en cours d'exécution. Si ce n'est pas le cas, la commande n'est pas reçue. Si c'est le cas, il semble que la commande est reçue, mais qu'elle n'est pas gérée correctement. Suivez le code à partir de là pour savoir quel est le problème.

Avez-vous de nombreux autres appareils détectables sur votre réseau ? Un trop grand nombre peut entraîner un ralentissement de la détection, voire parfois un échec.

Votre appareil reçoit-il la commande ?

Lorsque vous émettez la commande "Alexa, allumez mon téléviseur", l'exécution doit entrer dans votre WemoCallbackHandler::handleCallback handler (dans le fichier WemoCallbackHandler.h). Si vous ne l'avez pas encore fait, essayez d'afficher un message de débogage pour vous assurer qu'il se déclenche lorsque vous émettez votre commande. Essayez également de vous assurer qu'Alexa connaît votre appareil en disant "Alexa, découvrez les appareils" avant d'émettre votre commande. Cette étape suppose que la détection de périphérique a réussi.

La diode IR émet-elle ?

Comme décrit précédemment, lorsque vous pensez que votre appareil devrait émettre, pointez l'appareil photo de votre téléphone portable vers lui et regardez la diode à travers l'appareil photo. Bien que dans la vraie vie, vous ne puissiez rien voir, à travers l'appareil photo, cela devrait apparaître comme une lumière normale qui s'allume et clignote. Si vous voyez ceci, alors il émet… quelque chose.

Le signal IR est-il inversé ?

Votre diode IR peut être câblée de manière à ce que le signal soit essentiellement inversé. Veuillez patienter avec moi sur mon explication, car je ne suis pas un gars de l'électronique ou du câblage, mais le résultat d'un mauvais câblage de la diode sera que la lumière IR sera allumée par défaut, mais éteinte lorsque la bibliothèque IRSend a l'intention de tourner sur. Si tel est le cas, votre lumière infrarouge doit être allumée (visible à travers la caméra) par défaut, après l'exécution du code setup() , mais avant que quoi que ce soit d'autre ne se produise. Si vous deviez commenter tout le code à l'intérieur de loop() , vous devriez le voir rester allumé en permanence.

Pour voir plus clairement comment résoudre ce problème, rendez-vous dans le dossier library/IRemoteESP8266/src du code du tutoriel. Voir le constructeur :

 IRsend::IRsend(uint16_t IRsendPin, bool inverted) : IRpin(IRsendPin), periodOffset(PERIOD_OFFSET) { if (inverted) { outputOn = LOW; outputOff = HIGH; } else { outputOn = HIGH; outputOff = LOW; } }

C'est de l'argument « inversé » et de la logique qui le gère que nous parlons. Si votre câblage est inversé, la solution la plus simple est de faire un petit changement dans le code pour permettre cela (plutôt que de recâbler… mais si bien sûr vous pouvez le faire si vous préférez). Modifiez simplement cette ligne dans AlexaTvRemote.ino :

 //initialize the IR irSend = new IRsend(IR_PIN, false);

pour

 //initialize the IR irSend = new IRsend(IR_PIN, true);

Avez-vous le bon code de télécommande et la bonne commande ?

Si tout le reste semble aller bien, mais que le téléviseur n'obéit tout simplement pas, il est fort probable que quelque chose ne va pas avec le code IR. Essayez différents appels de fonction sur cette interface de bibliothèque infrarouge (par exemple, sendLG , sendPanasonic , sendSharp , etc.) ou assurez-vous que celui que vous utilisez correspond à votre matériel. Il est très peu probable que le matériel de votre téléviseur ne soit pas pris en charge par cette bibliothèque, mais je suppose que c'est techniquement possible.

Assurez-vous que le code que vous envoyez est celui qui convient à votre matériel. Vous devrez peut-être creuser sur google pour trouver le bon. Si tout le reste échoue, vous avez toujours la possibilité de détecter le code émis par votre télécommande de travail lorsque vous appuyez sur le bouton d'alimentation, mais il s'agit d'un didacticiel différent et nécessite un matériel différent.

Emballer

J'espère que tout a fonctionné pour vous. Si oui (et peut-être même si non), cela a été un bon moyen de se faire les dents sur plusieurs sujets à la fois :

• Alexa
• Programmation embarquée
• La puce ESP8266
• L'IDE Arduino

De plus, bien sûr, vous avez peut-être la légère commodité de pouvoir allumer/éteindre votre téléviseur par commande vocale.

Pourquoi le hack ?

Pourquoi est-ce un hack et ne fait-il pas partie de l'API de base d'Alexa ? Après avoir appris à développer ma première compétence Alexa, tout ce que je voulais vraiment savoir, c'était "comment puis-je simplement envoyer une commande directement d'Alexa à un autre appareil sur le réseau?" Dommage qu'Amazon n'ait pas exposé une API à part entière pour la communication entre l'appareil Alexa et les autres objets du réseau local, sans passer par le paradigme "skill" ou "smart-home" (où tout doit être envoyé à AWS avant de faire quoi que ce soit), mais ils ne l'ont tout simplement pas fait.

Essayez d'aller plus loin

Essayez une suite de commandes à distance pour mieux contrôler votre téléviseur, comme changer de chaîne et contrôler le volume. Testez les limites de la puce en voyant combien de commandes différentes vous pouvez écouter sur un ESP8266 (indice : le nombre dépasse à peine les deux chiffres, sans une programmation très intelligente). Si vous êtes bon avec le matériel, essayez de contrôler d'autres appareils non via IR, en les câblant directement aux puces ESP8266 ; comme l'éclairage et autres. Réinventez le wemo !