Beginnen Sie mit der IoT-Entwicklung: Ein ESP8266-Arduino-Tutorial

Das Ziel dieses ESP8266-Arduino-Tutorials ist es, sich mit der Embedded-Programmierung mit Arduino auf einem Chip vertraut zu machen, der in der Maker-Community (und Entwicklern im Allgemeinen) aufgrund seiner Zugänglichkeit und Benutzerfreundlichkeit im IoT-Bereich sehr beliebt geworden ist. Das Tutorial macht uns auch mit Alexa die Hände schmutzig, indem es einen inoffiziellen „Hack“ verwendet, um Alexa dazu zu bringen, unsere Gebote im Haus abzugeben (diese Technik ist nicht für den Einsatz in der Produktion gedacht, sondern nur für die Demonstration zu Hause). Versuchen Sie dies zu Hause, aber nicht bei der Arbeit.

Das Schöne an dieser Technik ist, dass wir sie in unseren eigenen vier Wänden verwenden können, um Alexa dazu zu bringen, fast buchstäblich alles zu automatisieren, was mit Strom betrieben wird. Als zusätzlichen Bonus erhalten wir einen Einblick in die eingebettete Programmierung mit Arduino, eine Fähigkeit, die heutzutage unter Mainstream-Programmierern vielleicht nicht mehr so ​​verbreitet ist. Schließlich machen wir uns an die Arbeit mit dem beliebten ESP8266-Chip, einem Favoriten unter Heimwerkern; Es ist ein erstaunlicher kleiner Chip mit der Fähigkeit, alle möglichen Dinge auszuführen, mit einem eingebauten WLAN-Chip, den wir für dieses Projekt benötigen werden. Dadurch können das Alexa-Gerät und der Chip direkt miteinander kommunizieren.

Nur ein paar Hintergrundinformationen zur Alexa-Programmierung: Das Programmiermodell „Skills“ von Alexa funktioniert wie folgt:

• Sie sprechen mit Ihrer Alexa.
• Alexa leitet Ihre Sprache den ganzen Weg zurück in die Cloud von Amazon.
• Der Sprachbefehl wird an einen Alexa-„Skill“ (ein Programm, das in Amazons Cloud läuft) weitergeleitet.

Der Alexa „Skill“ übernimmt die Abwicklung des Kommandos; normalerweise führt dies dazu, dass eine Antwort an das Alexa-Gerät zurückgesendet wird, wodurch es dem Benutzer etwas als Antwort sagt. Im Fall von Alexa IoT wird der Befehl an einen „Geräteschatten“ in der Cloud von Amazon weitergeleitet, was am Ende dazu führt, dass eine Antwort an ein anderes Gerät in Ihrem Zuhause gesendet wird. All das umgehen wir mit unserem Hack. Wir möchten das Alexa-Gerät dazu bringen, direkt mit unserem ESP8266-Chip in unserem Haus zu sprechen, ohne etwas an die Cloud und zurück zu senden. Wir möchten, dass die Alexa direkt eine Anfrage an unseren ESP8266 sendet, nur über und innerhalb unseres WLAN-Heimnetzwerks.

Unser Hack ist nicht wirklich ein Geheimnis. Wir werden unseren ESP8266 dazu bringen, einen Wemo Belkin zu „emulieren“, ein Gerät, das über eine spezielle Lizenz bei Amazon verfügt, die es ihm ermöglicht, direkt mit dem Alexa-Gerät zu kommunizieren, wobei die gesamte oben beschriebene Amazon-Cloud-Kommunikation umgangen wird.

Unser ESP8266 gibt vor, ein Wemo zu sein, und genießt das Privileg, Befehle direkt von Alexa empfangen zu können.

Basisplan für unser ESP8266 Arduino Tutorial

• Hören Sie auf dem ESP8266 nach, ob das Alexa-Gerät Sonden im lokalen WLAN-Netzwerk nach kompatiblen Geräten aussendet, und antworten Sie auf diese Sonden, indem Sie sagen: „Ich bin ein Wemo“.
• Sobald das Alexa-Gerät vertrauenswürdig ist, warten Sie auf weitere Befehle von diesem Gerät. Behandeln Sie sie, indem Sie IR-Codes über den IR-Sender senden und unseren Fernseher ein- und ausschalten.

Hardware-Anforderungen

Um dieses Tutorial abzuschließen, müssen Sie sich selbst einige Gegenstände besorgen, die alle leicht zu beschaffen sind.

• Jedes Alexa-Gerät. Ich habe dieses Tutorial mit einem Alexa Dot entwickelt. Funktioniert das Tutorial mit einem Echo-Simulator? Es könnte! (Aber ich habe es nicht getestet). Probieren Sie es aus, wenn Sie abenteuerlustig (oder sparsam) sind. Das Alexa-Gerät kostet Taschengeld, die Nutzung des Echosim ist aber kostenlos.
• Ein ESP8266-Chip. Sie kosten zum Zeitpunkt des Schreibens dieses Artikels nur ein paar USD. Du bekommst sie bei Ebay oder in jedem gut sortierten Baumarkt im Internet.
• Eine IR (Infrarot)-Diode. Sie müssen dies mit Ihrem ESP8266-Chip verdrahten, und dies müssen Sie selbst tun. Für dieses Projekt benötigen wir nur die Sendefunktionen; Der IR-Empfang ist uns egal. Achten Sie darauf, die Diode mit GND zu verbinden und 0 auszugeben, damit dieses Tutorial funktioniert. (Wenn Sie es auf andere Weise tun, ist das in Ordnung, aber Sie müssen auch dafür verantwortlich sein, den Tutorial-Code entsprechend zu ändern. Dieser Link kann Ihnen helfen. Beachten Sie, dass aufgrund des Nummerierungsschemas, das auf dem ESP8266 verwendet wird, Pin 0 kann als „D3“ gekennzeichnet sein.
• Ein serieller Adapter, der auf der einen Seite USB ist (zum Anschließen an Ihren Entwicklungscomputer) und die andere Seite in den ESP8266-Chip passt.
• Ein lokales WLAN-Netzwerk, für das Sie den Benutzernamen und das Passwort kennen.

Arduino-Softwaretools

• Arduino-IDE. Es gibt Versionen für alle gängigen Betriebssysteme, einschließlich Windows. Dieses Tutorial wurde auf der Ubuntu-Version entwickelt, aber ich habe Arduino auch unter Windows installiert und verwendet, keine Probleme.
• Die ESP8266-Entwicklungsbibliothek für Arduino.
• Treiber. Glücklicherweise sollten die Treiber für Ihren Adapter höchstwahrscheinlich Plug & Play sein, sodass keine zusätzlichen Treiber erforderlich sind.

Alles einrichten

• Installieren Sie die Arduino-IDE.
• Installieren Sie die ESP8266-Bibliothek mit Boards Manager.

So installieren Sie die ESP8266-Bibliothek mit Boards Manager:

• Öffnen Sie in der Arduino IDE File -> Preferences .
• Geben Sie diese URL in „Additional Boards Manager URL“ ein: http://arduino.esp8266.com/stable/package_esp8266com_index.json
• OK klicken

• Gehen Sie zum Boards Manager ( Extras -> Board: [aktuelles Board] -> Boards Manager ).

• Geben Sie im Textfeld „Filter“ „ESP8266“ ein.
• Sie sollten jetzt einen Eintrag für „esp8266“ erhalten, nachdem Sie den Manager für zusätzliche Boards hinzugefügt haben. Wählen Sie es aus und klicken Sie auf „Installieren“.

• Warten Sie eine Weile – es dauert einige Zeit, alles herunterzuladen.
• Starten Sie Ihre Arduino IDE neu.
• Öffnen Sie Tools -> Board: und scrollen Sie dieses Mal nach unten zu „Generic ESP8266 Module“ und wählen Sie es aus.

Hinzufügen von Bibliotheken von Drittanbietern

Arduino bietet viele verschiedene Möglichkeiten, Ihrem Projekt oder „Sketch“, wie sie es nennen, externe Bibliotheken hinzuzufügen. Um die Dinge so einfach wie möglich zu halten, werden wir für dieses Tutorial nur die schnellste Erklärung nehmen, nämlich das einfache Kopieren von Ordnern. Wir müssen genau zwei externe Bibliotheken hinzufügen, damit das Tutorial funktioniert: IRemoteESP8266 und https://github.com/me-no-dev/ESPAsyncTCP.

• Suchen Sie im Tutorial-Code in GitHub das Verzeichnis „libraries“.
• Suchen Sie im Root-Installationsverzeichnis für Arduino (z. B. C:\Program Files\Arduino) das Unterverzeichnis „libraries“.
• Kopieren Sie das Verzeichnis IRemoteESP8266 aus dem Verzeichnis „libraries“ des Tutorials in das Verzeichnis „libraries“ von Arduino.
• Kopieren Sie das Verzeichnis ESPAsyncTCP aus dem Verzeichnis „libraries“ des Tutorials in das Verzeichnis „libraries“ von Arduino.
• Starten Sie die Arduino IDE neu.

Jetzt sind die Bibliotheken für IR-Übertragung und asynchrones TCP im Projekt enthalten.

Einstellungen

Das Bild unten zeigt typische Einstellungen, die für mich und meine Hardware funktionieren, aber für jeden Benutzer unterschiedlich sein können. Sie können die folgenden Einstellungen ausprobieren, aber es besteht die Möglichkeit, dass Sie sie basierend auf Ihrem speziellen Chip und Adapter anpassen müssen. Meins ist zum Beispiel nodemcu, also musste ich die Reset-Methode von „ck“ (Standard) auf „nodemcu“ ändern. Stellen Sie außerdem „Debug-Port“ auf „Serial“, damit Sie den seriellen Debugger verwenden können. Meins ist ein sehr typisches Setup, also können Sie meine Einstellungen als Basis verwenden; Ich sage nur, seien Sie nicht überrascht, wenn Sie mit ihnen herumspielen müssen, um den Kompilierungs- und Flash-Prozess zum Laufen zu bringen.

Beweisen Sie Ihr Setup mit einem ESP8266 Hello World

Arduino-Projekte beginnen mit einer .ino-Datei. Die .ino-Datei definiert zwei Einstiegspunkte: Setup und Loop. Für unser „Hallo Welt“ schalten wir ein kleines Licht auf dem ESP8266 ein, nur um zu überprüfen, ob unser Code funktioniert.

 //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); }

Kompilieren und flashen Sie den Code

Kompilieren und Flashen sind einfache Schritte, wenn Ihr bisheriges Setup korrekt ist. Um ohne Flashen zu kompilieren, gehen Sie einfach zu Sketch -> Verify/Compile aus dem Arduino-Menü.

Um den Code auf den Chip zu flashen und zu kompilieren, wählen Sie Sketch -> Upload aus dem Arduino-Menü.

Wenn der Blitz erfolgreich ist, sehen Sie eine Fortschrittsanzeige, die von 0 % auf 100 % wechselt, während dieser Zeit wird die LED auf Ihrem Chip höchstwahrscheinlich tatsächlich blinken oder blinken.

So testen Sie, ob das serielle Debugging funktioniert:

• Stellen Sie zunächst sicher, dass der Debug-Port auf Serial eingestellt ist ( Extras -> Debug-Port ).
• Nachdem Ihr Code auf dem Chip geflasht ist, wählen Sie Tools -> Serial Monitor .

Ausgabe des seriellen Debuggers nach erfolgreichem Start:

Super, das funktioniert also; Als nächstes wollen wir unsere IR-Ausgabe überprüfen. Lassen Sie uns ein Signal durch unseren IR-Sender senden und überprüfen, ob das Signal durchkommt.

Wir werden eine vorhandene Arduino IR-Bibliothek verwenden, um uns zu helfen. Eines der großartigen Dinge an Arduino ist, wie einfach es ist, Bibliotheken und Module ein- und auszurasten. Sehr erfrischend für ein C++-Framework!

Befolgen Sie einfach die Anweisungen in der README-Datei dieses Git-Repositorys, um es in Arduino zu installieren.

Dieser Code lässt den IR-Sender nur wiederholt blinken. IR ist für das menschliche Auge unsichtbar, aber es gibt einen Profi-Tipp zum Testen; Führen Sie diesen Code aus, überprüfen Sie (über den Debugger), dass er auf Ihrem Chip ausgeführt wird, und öffnen Sie dann die Kamera Ihres Mobilgeräts. Schauen Sie durch Ihre Kamera direkt auf die IR-Diodenlampe. Wenn es funktioniert, sollten Sie sehen, wie sich die Glühbirne sichtbar ein- und ausschaltet. Sie können dies auch mit jeder funktionierenden Fernbedienung (z. B. einer Standard-TV-Fernbedienung) versuchen. Der folgende Code sollte dazu führen, dass die IR-Lampe alle 0,5 Sekunden zu blinken beginnt. Tatsächlich sendet es den LG-Ein / Aus-Befehl, sodass Ihr LG-Fernseher möglicherweise tatsächlich aus- und eingeschaltet wird, wenn er sich in der Nähe befindet.

 #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); }

Beginnen Sie mit dem ESP8266-Tutorial

Wenn bisher alles funktioniert hat, können wir meiner Meinung nach zufrieden sein, dass unsere Grundausstattung und unser Setup funktionieren, und wir sind bereit, mit dem Kern des Tutorials zu beginnen.

Mit WLAN verbinden

Zuerst müssen wir uns mit dem lokalen WLAN verbinden. Der folgende Code versucht, eine Verbindung zum WLAN herzustellen, und meldet den Erfolg der Verbindung (über den seriellen Debugger). Vergessen Sie im Codebeispiel nicht, den Wert von myWifiSsid durch den Benutzernamen Ihres WLAN-Netzwerks und den Wert von myWifiPassword durch das richtige Passwort zu ersetzen.

 #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() { }

Führen Sie den Wemo-Server aus

In Verbindung gebracht? Gut. Jetzt kommen wir zum Kern des Projekts: dem Wemo-Server.

Mein eigener Wemo-Emulator ist in den Quelldateien für dieses Tutorial enthalten. Jetzt können Sie Google durchsuchen und einen einfacheren Wemo-Emulator finden. Sie können eine finden, die mit weniger Code geschrieben wurde und leicht zu verstehen ist. Fühlen Sie sich auf jeden Fall frei, zu untersuchen, zu experimentieren, Ihre eigenen zu schreiben usw. Das gehört dazu, dieses Tutorial zu Ihrem eigenen zu machen.

Die Argumentation hinter mir ist, dass es ESPAsyncTCP verwendet. Warum ist das gut? Nun, es gibt nur so viele Server (oder Geräte), die Sie mit dieser Methode auf dem ESP8266 ausführen können, bevor es unzuverlässig wird, in dem Sinne, dass Alexa anfängt, Geräte zu vermissen (sie nicht zu finden), Befehle fallen gelassen werden und die Leistung wird langsam. Ich finde, dass diese Zahl durch die Verwendung der ESPAsyncTCP-Bibliothek maximiert wird.

Ohne sie habe ich festgestellt, dass sich Unzuverlässigkeit bei etwa 10-12 Geräten einschleicht; Ich finde, dass sich diese Zahl damit auf etwa 16 erhöht. Falls Sie dieses Tutorial erweitern und die Grenzen dessen ausloten möchten, was der Chip leisten kann, würde ich empfehlen, meine Version zu verwenden. Wenn Sie nur zu Ihrem eigenen Verständnis eine einfachere Version sehen möchten, können Sie bei Google nach „wemo emulator Arduino“ suchen; Sie sollten eine Vielzahl von Beispielen finden.

Jetzt müssen wir die ESPAsyncTCP-Bibliothek installieren. Installieren Sie es genauso wie wir es mit der IR-Bibliothek getan haben; Gehen Sie zur Git-Seite und folgen Sie den Anweisungen.

Diese Bibliothek ist auch in meinem esp8266-Arduino-Beispielcode enthalten. Hier ist nur der Code, um die WLAN-Verbindung zu öffnen, auf die Alexa-Discovery-Anfrage zu hören und sie zu verarbeiten, indem eine „I am Wemo“-Antwort zurückgegeben wird.

 #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(); } }

Vorabtest

Testen Sie, was wir bisher haben (WLAN und Emulator), indem Sie es mit Alexa ausführen. Dieses Tutorial geht davon aus, dass Ihr Alexa-Gerät bei Ihnen zu Hause eingerichtet und installiert ist.

Entdeckung testen:

Sagen Sie zu Alexa: „Alexa, finde Geräte.“

Dies veranlasst Alexa, eine UDP-Anfrage in Ihrem lokalen WLAN-Netzwerk zu senden und nach Wemos und anderen kompatiblen Geräten zu suchen. Diese Anfrage sollte im Aufruf von wemulator->listen(); in der Funktion loop(). Dies wiederum leitet es an die handleUDPPacket(*) Methode von Wemulator weiter. Eine Antwort wird in der Methode nextUDPResponse() gesendet. Beachten Sie den Inhalt dieser Antwort:

 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";

Dies ist der Code, der Alexa sagt: „Ich bin ein Wemo (Belkin), wie kann ich Ihnen helfen?“ Sobald Alexa diese Antwort erhält, weiß und merkt es sich, dass zukünftige Smart-Home-Befehle möglicherweise an dieses Gerät weitergeleitet werden.

Die Ausgabe des seriellen Debuggers sollte an dieser Stelle wie im Bild unten aussehen. Wenn die Entdeckung abgeschlossen ist, teilt Alexa Ihnen mündlich mit, dass es „[N] Geräte“ in Ihrem Netzwerk entdeckt hat.

Beachten Sie in der Funktion setup() den folgenden Ausschnitt:

 new WemoCallbackHandler(&commandReceived)

Dies ist der Rückruf, bei dem wir Befehle von Alexa erfassen. Sein Körper ist in WemoCallbackHandler.h (WemoCallbackHandler::handleCallback) definiert. Sobald wir einen Befehl von Alexa erfasst haben, können wir damit machen, was wir wollen. In den Zeilen davor haben wir mögliche Befehle eingerichtet, die mit diesen Codezeilen verwendet werden können:

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

Das sind also 4 separate „Server“ oder Listener, die wir auf dem Chip betreiben. Dadurch wird die Möglichkeit eingerichtet, Alexa einen der folgenden Befehle zu sagen:

Alexa, Fernseher einschalten Alexa, Fernseher ausschalten Alexa, Fernseher einschalten Alexa, Fernseher ausschalten Alexa, Fernseher einschalten Alexa, Fernseher ausschalten Alexa, Fernseher einschalten Alexa, Fernseher ausschalten

Und so werden wir es testen. Wir erwarten, dass das Sagen eines dieser Befehle unseren Code aufwecken und diesen Rückruf eingeben sollte, wo wir damit machen können, was wir wollen.

Fügen Sie den IR-Befehl hinzu

Jetzt, da wir den Befehl erhalten, ist es an der Zeit, ihn zu handhaben, indem wir unseren Fernseher ein- und ausschalten. Das wird also alles sein – WLAN, Wemo-Emulator und IR – alles zusammen. Mein Fernseher ist ein LG, also habe ich die entsprechende Sequenz zum Ein- und Ausschalten nachgeschlagen und diese über die sendNEC-Funktion unserer IR-Bibliothek gesendet (LG verwendet das NEC-Protokoll). IR-Codierung/Decodierung ist ein separates Thema für sich, wobei eine Nachricht in der Modulation eines Signals codiert wird; es ist eine Spezifikation von sehr präzisen Zeitangaben, Markierungen und Zwischenräumen. Jeder Hersteller neigt dazu, sein eigenes proprietäres Protokoll für Befehle und mit unterschiedlichen Timings zu verwenden; Es ist ziemlich interessant, und Sie können tiefer graben, indem Sie sich den Quellcode dieser IR-Bibliothek ansehen, googeln usw. Aber zu unserer Bequemlichkeit werden die Details von all dem von unserer IR-Bibliothek für uns erledigt.

Dein Fernseher ist kein LG? Einfach den richtigen Code googeln. Hier ist der Befehl für Sony-Fernseher (Vorbehalt: nicht getestet):

 irSend.sendSony(0xa90, 12);

Wenn Sie wirklich selbst Hand anlegen möchten, können Sie einen IR-Empfänger aufstellen, Ihre Fernbedienung (oder einen beliebigen IR-Sender) darauf richten und die gesendeten Codes entschlüsseln. das ist aber ein anderes Tutorial.

End-to-End-Test

• Platzieren Sie Ihre Alexa überall dort, wo sie Sie hören kann.
• Platzieren Sie Ihren ESP8266 mit angeschlossener IR-Diode in Reichweite der Fernbedienung des Fernsehers.
• Sagen Sie „Alexa, finde Geräte.“ Warten Sie, bis es Erfolg meldet (es sollte mindestens ein Gerät entdeckt haben).
• Sagen Sie „Alexa, schalte meinen Fernseher ein“ oder „Alexa, schalte meinen Fernseher aus“.

Alexa sollte Ihren Befehl verstehen (als Smarthome-Befehl, der nicht auf einen bestimmten Skill gerichtet ist), nach einem lokalen Gerät suchen, um ihn zu verarbeiten, und den Befehl an das Gerät (Ihren ESP8266) senden. Ihr Gerät sollte es empfangen und den Fernbedienungsbefehl an den Fernseher senden. Sie können Ihre Diode durch eine Handykamera betrachten, um sicherzustellen, dass sie emittiert.

Da der IR-Code zum Ausschalten eines Fernsehgeräts derselbe ist wie der Code zum Einschalten, spielt es keine Rolle, ob Sie den Befehl zum Ein- oder Ausschalten geben. Es ist derselbe Code und schaltet den Zustand um. Wenn der Fernseher ausgeschaltet ist, sollte er sich einschalten, und wenn er eingeschaltet ist, sollte er sich ausschalten.

Fehlerbehebung

Bist du mit dem WLAN verbunden?

Haben Sie den richtigen Benutzernamen/das richtige Passwort in die richtigen Variablenwerte eingegeben?

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

Erhalten Sie eine Fehlermeldung oder einen Fehler über den seriellen Debug-Port, wenn Sie sich mit dem WLAN verbinden?

Ist Ihr WLAN eingeschaltet und können Sie sich auf andere Weise damit verbinden?

Wird Ihr Gerät von Alexa erkannt?

Alexa sendet Anfragen, um Geräte zu entdecken, wenn Sie „Alexa, finde Geräte“ sagen.

Ihr Alexa muss ordnungsgemäß konfiguriert und eingerichtet und mit demselben WLAN-Netzwerk wie Ihr ESP8266 verbunden sein.

Schauen Sie in Fauxmo.h nach. Siehe die Funktion Fauxmo::handle(). Dies ist der erste Code, der ausgeführt wird, sobald der ESP8266 den Anruf gehört hat. Fügen Sie Debug-Meldungen ein, um zu sehen, ob danach Code vorhanden ist

 if (len > 0) {

läuft. Ist dies nicht der Fall, wird der Befehl nicht empfangen. Wenn dies der Fall ist, scheint der Befehl empfangen, aber nicht korrekt verarbeitet zu werden. Folgen Sie dem Code von dort, um herauszufinden, was das Problem ist.

Haben Sie viele andere erkennbare Geräte in Ihrem Netzwerk? Zu viele können dazu führen, dass die Discovery langsamer ausgeführt wird oder manchmal sogar fehlschlägt.

Empfängt Ihr Gerät den Befehl?

Wenn Sie den Befehl „Alexa, schalte meinen Fernseher ein“ ausgeben, sollte die Ausführung Ihren WemoCallbackHandler::handleCallback handler (in der Datei „WemoCallbackHandler.h“). Wenn Sie dies nicht getan haben, versuchen Sie, dort eine Debug-Nachricht auszugeben, um sicherzustellen, dass sie ausgelöst wird, wenn Sie Ihren Befehl ausgeben. Versuchen Sie auch sicherzustellen, dass Alexa Ihr Gerät kennt, indem Sie „Alexa, finde Geräte“ sagen, bevor Sie Ihren Befehl ausgeben. Bei diesem Schritt wird davon ausgegangen, dass die Geräteerkennung erfolgreich war.

Leuchtet die IR-Diode?

Wenn Sie denken, dass Ihr Gerät emittieren sollte, richten Sie, wie zuvor beschrieben, die Kamera Ihres Mobiltelefons darauf und schauen Sie durch die Kamera auf die Diode. Obwohl Sie im wirklichen Leben nichts sehen können, sollte es durch die Kamera als normales Licht erscheinen, das aufleuchtet und blinkt. Wenn Sie das sehen, dann sendet es ... etwas aus.

Ist das IR-Signal umgekehrt?

Ihre IR-Diode kann so verdrahtet sein, dass das Signal im Wesentlichen umgekehrt ist. Bitte halten Sie sich an meine Erklärung, da ich kein Elektronik- oder Verdrahtungstyp bin, aber das Ergebnis einer falschen Verdrahtung der Diode ist, dass das IR-Licht standardmäßig eingeschaltet ist, aber ausgeschaltet wird, wenn die IRSend-Bibliothek einschalten möchte es an. Wenn dies der Fall ist, sollte Ihr IR-Licht standardmäßig eingeschaltet sein (durch die Kamera sichtbar), nachdem der setup() -Code ausgeführt wurde, aber bevor irgendetwas anderes passiert. Wenn Sie den gesamten Code innerhalb von loop() auskommentieren würden, sollten Sie sehen, dass er kontinuierlich eingeschaltet bleibt.

Um deutlicher zu sehen, wie Sie dies beheben können, gehen Sie in den Ordner „libraries/IRemoteESP8266/src “ des Tutorial-Codes. Siehe Konstruktor:

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

Das „umgekehrte“ Argument und die Logik, die damit umgeht, ist das, worüber wir sprechen. Wenn Ihre Verkabelung invertiert ist, besteht die einfachste Lösung darin, eine kleine Änderung im Code vorzunehmen, um dies zu ermöglichen (anstatt neu zu verkabeln ... aber wenn Sie möchten, können Sie das natürlich tun). Ändern Sie einfach diese Zeile in AlexaTvRemote.ino:

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

zu

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

Haben Sie den richtigen Fernbedienungscode und -befehl?

Wenn alles andere in Ordnung zu sein scheint, aber der Fernseher einfach nicht gehorcht, ist es wahrscheinlich, dass etwas mit dem IR-Code nicht stimmt. Probieren Sie verschiedene Funktionsaufrufe auf dieser IR-Bibliotheksschnittstelle aus (z. B. sendLG , sendPanasonic , sendSharp usw.) oder stellen Sie sicher, dass die von Ihnen verwendete zu Ihrer Hardware passt. Es ist sehr unwahrscheinlich, dass die Hardware Ihres Fernsehers nicht von dieser Bibliothek unterstützt wird, aber ich denke, es ist technisch möglich.

Stellen Sie sicher, dass der von Ihnen gesendete Code der richtige für Ihre Hardware ist. Möglicherweise müssen Sie Google durchsuchen, um das Richtige zu finden. Wenn alles andere fehlschlägt, besteht immer die Möglichkeit, den Code zu erkennen, der von Ihrer funktionierenden Fernbedienung ausgegeben wird, wenn Sie die Ein- / Aus-Taste drücken - aber das ist ein anderes Tutorial und erfordert andere Hardware.

Einpacken

Hoffentlich hat bei dir alles geklappt. Wenn ja (und vielleicht sogar wenn nicht), war dies eine gute Möglichkeit, sich bei mehreren Themen gleichzeitig zu vertiefen:

• Alexa
• Eingebettete Programmierung
• Der ESP8266-Chip
• Die Arduino-IDE

Außerdem haben Sie natürlich den vielleicht kleinen Komfort, Ihren Fernseher per Sprachbefehl ein- und ausschalten zu können.

Warum der Hack?

Warum ist dies ein Hack und nicht Teil der grundlegenden API für Alexa? Nachdem ich gelernt hatte, wie ich meinen ersten Alexa-Skill entwickle, wollte ich eigentlich nur wissen: „Wie kann ich einfach einen Befehl direkt von Alexa an ein anderes Gerät im Netzwerk senden?“ Es ist eine Schande, dass Amazon keine vollwertige API für die Kommunikation zwischen dem Alexa-Gerät und anderen Objekten im lokalen Netzwerk bereitgestellt hat, ohne das „Skill“- oder „Smart-Home“-Paradigma zu durchlaufen (wobei alles an AWS gesendet werden muss bevor sie irgendetwas tun), aber sie haben es einfach nicht getan.

Versuchen Sie, es weiter zu bringen

Probieren Sie eine Reihe von Fernbedienungsbefehlen aus, um Ihren Fernseher umfassender zu steuern, z. B. den Kanal zu wechseln und die Lautstärke zu regeln. Testen Sie die Grenzen des Chips, indem Sie sehen, wie viele verschiedene Befehle Sie auf einem ESP8266 hören können (Tipp: Die Zahl bricht kaum zweistellig, ohne eine sehr clevere Programmierung). Wenn Sie sich mit Hardware auskennen, versuchen Sie, andere Geräte nicht über IR zu steuern, indem Sie sie direkt mit ESP8266-Chips verbinden. wie Beleuchtung und so. Wemo neu erfinden!