Comience con el desarrollo de IoT: un tutorial de ESP8266 Arduino

El objetivo de este tutorial de ESP8266 Arduino es familiarizarse con la programación integrada con Arduino en un chip que se ha vuelto muy popular entre la comunidad de fabricantes (y desarrolladores en general) por su accesibilidad y facilidad de uso en el espacio IoT. El tutorial también nos ensuciará las manos con Alexa usando un "truco" no oficial para que Alexa cumpla nuestras órdenes en el hogar (esta técnica no está diseñada para su uso en producción, solo para demostración en el hogar). Intente esto en casa, pero no en el trabajo.

La belleza de esta técnica es que podemos usarla en nuestros propios hogares para hacer que Alexa automatice casi literalmente cualquier cosa que funcione con electricidad. Como beneficio adicional, obtenemos una idea de la programación integrada con Arduino, una habilidad que tal vez no sea tan común entre los programadores convencionales en estos días. Finalmente, nos ponemos manos a la obra con el popular chip ESP8266, uno de los favoritos entre los aficionados al bricolaje; es un pequeño chip increíble con la capacidad de ejecutar todo tipo de cosas, con un chip Wifi incorporado que necesitaremos para este proyecto. Es lo que permitirá que el dispositivo Alexa y el chip se comuniquen entre sí directamente.

Solo algunos antecedentes sobre la programación de Alexa: el modelo de programación de "habilidades" de Alexa funciona así:

• Hablas con tu Alexa.
• Alexa enruta tu voz hasta la nube de Amazon.
• El comando de voz se enruta a una "habilidad" de Alexa (un programa que se ejecuta en la nube de Amazon).

La "habilidad" de Alexa se hace cargo del manejo del comando; normalmente da como resultado que se envíe una respuesta al dispositivo Alexa, lo que hace que le diga algo al usuario en respuesta. En el caso de Alexa IoT, el comando se enruta a una "sombra del dispositivo" en la nube de Amazon, lo que al final da como resultado que se envíe una respuesta a algún otro dispositivo en su hogar. Estamos pasando por alto todo eso con nuestro truco. Queremos hacer que el dispositivo Alexa se comunique directamente con nuestro chip ESP8266, dentro de nuestra casa, sin enviar nada a la nube y viceversa. Queremos que Alexa envíe directamente una solicitud a nuestro ESP8266, solo dentro y fuera de nuestra red wifi doméstica.

Nuestro truco no es realmente un secreto. Vamos a hacer que nuestro ESP8266 “emule” un Wemo Belkin, un dispositivo que tiene una licencia especial con Amazon que le permite comunicarse directamente con el dispositivo Alexa, evitando toda esa comunicación en la nube de Amazon descrita anteriormente.

Fingiendo ser un Wemo, nuestro ESP8266 disfruta del privilegio de poder recibir comandos directamente desde Alexa.

Plan Básico para nuestro Arduino ESP8266 Tutorial

• Escuche en el ESP8266 el dispositivo Alexa que envía sondas en la red wifi local para dispositivos compatibles y responda a estas sondas diciendo "Soy un Wemo".
• Una vez que el dispositivo Alexa confíe en ti, escucha más comandos de dicho dispositivo. Manejarlos enviando códigos IR a través del transmisor IR, encendiendo/apagando nuestro televisor.

Requisitos de hardware

Para completar este tutorial, necesitará obtener algunos elementos por su cuenta, todos los cuales son fáciles de obtener.

• Cualquier dispositivo Alexa. He desarrollado este tutorial con un Alexa Dot. ¿Funcionará el tutorial con un simulador Echo? ¡Que podría! (Pero no lo he probado). Pruébalo si te sientes aventurero (o frugal). El dispositivo Alexa cuesta dinero de bolsillo, pero el uso de Echosim es gratuito.
• Un chip ESP8266. Cuestan unos pocos dólares en el momento de escribir este artículo. Puede obtenerlos en Ebay, o en cualquier tienda de hardware bien surtida en línea.
• Un diodo IR (infrarrojo). Deberá conectar esto a su chip ESP8266, y tendrá que hacerlo usted mismo. Para este proyecto, solo necesitamos las capacidades de envío; no nos importa recibir IR. Asegúrese de conectar el diodo a GND y la salida 0 para que este tutorial funcione. (Si lo hace de otra manera, está bien, pero también tendrá que ser responsable de modificar el código del tutorial en consecuencia. Este enlace puede ayudarlo. Tenga en cuenta que debido al esquema de numeración utilizado en el ESP8266, pin 0 puede etiquetarse como "D3".
• Un adaptador serial que en un lado es USB (para conectarlo a su computadora de desarrollo) y el otro lado encaja en el chip ESP8266.
• Una red wifi local de la que conoces el usuario y la contraseña.

Herramientas de software Arduino

• IDE de Arduino. Hay versiones para todos los principales sistemas operativos, incluido Windows. Este tutorial se desarrolló en la versión de Ubuntu, pero también instalé y usé Arduino en Windows, sin problemas.
• La biblioteca de desarrollo ESP8266 para Arduino.
• Conductores. Afortunadamente, lo más probable es que los controladores para su adaptador sean plug & play, por lo que no se requieren controladores adicionales.

Configurando todo

• Instale el IDE de Arduino.
• Instale la biblioteca ESP8266 usando Boards Manager.

Para instalar la biblioteca ESP8266 usando Boards Manager:

• En Arduino IDE, abra Archivo -> Preferencias .
• Ingrese esta URL en "URL del administrador de tableros adicionales": http://arduino.esp8266.com/stable/package_esp8266com_index.json
• Haga clic en Aceptar

• Vaya al Administrador de tableros ( Herramientas -> Tablero: [tablero actual] -> Administrador de tableros ).

• En el cuadro de texto "filtro", escriba "ESP8266".
• Debería obtener una entrada para "esp8266" ahora que ha agregado el administrador de tableros adicionales. Elíjalo y haga clic en "instalar".

• Espera un momento: lleva un tiempo descargar todo.
• Reinicie su IDE de Arduino.
• Abra Herramientas -> Tablero: y, esta vez, desplácese hacia abajo hasta "Módulo genérico ESP8266" y selecciónelo.

Adición de bibliotecas de terceros

Arduino ofrece muchas formas diferentes de agregar bibliotecas externas a su proyecto, o "Sketch", como lo llaman. Para mantener las cosas lo más simples posible, para este tutorial, solo explicaremos lo más rápido, que es simplemente copiar carpetas. Necesitaremos agregar exactamente dos bibliotecas externas para que funcione el tutorial: IRemoteESP8266 y https://github.com/me-no-dev/ESPAsyncTCP.

• En el código del tutorial en GitHub, busque el directorio "bibliotecas".
• En el directorio raíz de instalación de Arduino (p. ej., C:\Archivos de programa\Arduino), busque el subdirectorio "bibliotecas".
• Copie el directorio IRemoteESP8266 del directorio "bibliotecas" del tutorial en el directorio "bibliotecas" de Arduino.
• Copie el directorio ESPAsyncTCP del directorio de "bibliotecas" del tutorial en el directorio de "bibliotecas" de Arduino.
• Reinicie el IDE de Arduino.

Ahora las bibliotecas para transmisión IR y TCP asíncrono están incluidas en el proyecto.

Ajustes

La siguiente imagen muestra configuraciones típicas, que funcionan para mí y mi hardware, pero pueden variar para cada usuario. Puede probar las configuraciones a continuación, pero existe la posibilidad de que tenga que ajustarlas en función de su chip y adaptador en particular. El mío es nodemcu, por ejemplo, así que tuve que cambiar el método de reinicio de "ck" (el predeterminado) a "nodemcu". Además, configure el "puerto de depuración" en "serie" para que pueda usar el depurador en serie. La mía es una configuración muy típica, por lo que puede usar mi configuración como base; Solo digo que no se sorprenda si tiene que meterse con ellos para que el proceso de compilación y flash funcione.

Pruebe su configuración con un ESP8266 Hello World

Los proyectos de Arduino comienzan con un archivo .ino. El archivo .ino define dos puntos de entrada: configuración y bucle. Para nuestro "hola mundo", vamos a encender una lucecita, en el ESP8266, solo para verificar que nuestro código funciona.

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

Compilar y flashear el código

Compilar y flashear son pasos sencillos, si su configuración hasta ahora es correcta. Para compilar sin flashear, simplemente vaya a Bosquejo -> Verificar/Compilar desde el menú de Arduino.

Para actualizar el código al chip y compilarlo, seleccione Bosquejo -> Cargar en el menú de Arduino.

Si el flash tiene éxito, verá una pantalla de progreso que va del 0 % al 100 %, tiempo durante el cual lo más probable es que el LED de su chip parpadee o parpadee.

Para probar que la depuración serial está funcionando:

• Primero asegúrese de que el puerto de depuración esté configurado en Serie ( Herramientas -> Puerto de depuración ).
• Una vez que su código haya terminado de parpadear en el chip, seleccione Herramientas -> Monitor en serie .

Salida del depurador en serie después de un inicio exitoso:

Genial, entonces eso funciona; a continuación, queremos verificar nuestra salida IR. Enviemos una señal a través de nuestro transmisor IR y verifiquemos que la señal esté llegando.

Vamos a hacer uso de una biblioteca Arduino IR existente para ayudarnos. Una de las mejores cosas de Arduino es lo fácil que es insertar y extraer bibliotecas y módulos. ¡Muy refrescante para un framework C++!

Simplemente siga las instrucciones en el archivo README de Git repo para instalarlo en Arduino.

Este código solo parpadea repetidamente en el transmisor IR. IR es invisible para el ojo humano, pero hay un consejo profesional para probarlo; ejecute este código, verifique (a través del depurador) que se está ejecutando en su chip, luego abra la cámara de su dispositivo móvil. Mire directamente a la bombilla del diodo IR a través de su cámara . Si funciona, debería ver que la bombilla se enciende y se apaga visiblemente. También puede probar esto con cualquier control remoto que funcione (por ejemplo, un control remoto de TV estándar). El siguiente código debería hacer que la bombilla IR comience a parpadear cada 0,5 segundos. En realidad, envía el comando de encendido/apagado de LG, por lo que puede apagar y encender su televisor LG si está cerca.

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

Comience el tutorial ESP8266

Si todo ha funcionado hasta ahora, creo que podemos estar satisfechos de que nuestro equipo y configuración básicos funcionan, y estamos listos para comenzar la parte principal del tutorial.

Conectarse a Wi-Fi

Primero, vamos a necesitar conectarnos al wifi local. El siguiente código intentará conectarse a Wifi e informará sobre el éxito de la conexión (a través del depurador en serie). En el ejemplo de código, no olvide reemplazar el valor de myWifiSsid con el nombre de usuario de su red wifi y reemplace el valor de myWifiPassword con la contraseña correcta.

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

Ejecute el servidor Wemo

¿Conectado? Bueno. Ahora estamos llegando al meollo del proyecto: el servidor Wemo.

Mi propio Wemo Emulator está incluido en los archivos fuente de este tutorial. Ahora, puede buscar en Google y encontrar un emulador de Wemo más simple. Puede encontrar uno que esté escrito con menos código y que sea fácil de entender. Por todos los medios, siéntete libre de examinar, experimentar, escribir el tuyo propio, etc. Todo eso es parte de hacer que este tutorial sea tuyo.

El razonamiento detrás del mío es que usa ESPAsyncTCP. ¿Por qué es esto bueno? Bueno, hay tantos servidores (o dispositivos) que puede ejecutar en el ESP8266 usando este método antes de que comience a perder confiabilidad, en el sentido de que Alexa comenzará a perder dispositivos (sin encontrarlos), los comandos se perderán y el rendimiento se vuelve lento Encuentro que este número se maximiza mediante el uso de la biblioteca ESPAsyncTCP.

Sin él, he encontrado que la falta de confiabilidad se infiltra en alrededor de 10 a 12 dispositivos; con él, encuentro que el número sube a alrededor de 16. En caso de que desee ampliar este tutorial y explorar los límites de lo que puede hacer el chip, le recomiendo usar mi versión. Si desea ver una versión más simple solo para su propia comprensión, siéntase libre de buscar "wemo emulator Arduino" en Google; usted debe encontrar una gran cantidad de ejemplos.

Ahora, tenemos que instalar la biblioteca ESPAsyncTCP. Instálelo tal como hicimos con la biblioteca IR; vaya a la página de Git y siga las instrucciones.

Esta biblioteca también está incluida en mi código de ejemplo de arduino esp8266. Aquí está solo el código para abrir la conexión wifi, escuchar la solicitud de descubrimiento de Alexa y manejarla devolviendo una respuesta "Soy 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(); } }

Prueba previa

Probar lo que tenemos hasta ahora (wifi y emulador), ejecutándolo con Alexa. Este tutorial asume que su dispositivo Alexa está configurado e instalado en su hogar.

Prueba de descubrimiento:

Dígale a Alexa: "Alexa, descubre dispositivos".

Esto hará que Alexa transmita una solicitud UDP en su red wifi local, buscando Wemos y otros dispositivos compatibles. Esta solicitud debe recibirse en la llamada a wemulator->listen(); en la función loop(). Esto, a su vez, lo enruta al método handleUDPPacket(*) de Wemulator. Se envía una respuesta en el método nextUDPResponse() . Tenga en cuenta el contenido de esa respuesta:

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

Este es el código que le dice a Alexa “Soy un Wemo (Belkin), ¿cómo puedo ayudarte?” Una vez que Alexa recibe esta respuesta, sabe y recuerda que los futuros comandos del hogar inteligente pueden enrutarse a este dispositivo.

La salida del depurador en serie en este punto debería verse como la imagen a continuación. Cuando termine de descubrir, Alexa le dirá verbalmente que ha "descubierto [N] dispositivos" en su red.

En la función setup() , tenga en cuenta el siguiente fragmento:

 new WemoCallbackHandler(&commandReceived)

Esta es la devolución de llamada donde capturaremos los comandos de Alexa. Su cuerpo está definido en WemoCallbackHandler.h (WemoCallbackHandler::handleCallback). Una vez que hemos capturado un comando de Alexa, podemos hacer lo que queramos con él. En las líneas anteriores, hemos configurado posibles comandos que se pueden usar, con estas líneas de código:

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

Estos son 4 "servidores" u oyentes separados que estamos ejecutando en el chip. Esto configura la capacidad de decir cualquiera de los siguientes comandos a Alexa:

Alexa, enciende la televisión Alexa, apaga la televisión Alexa, enciende la televisión Alexa, apaga la televisión Alexa, enciende mi televisión Alexa, apaga mi televisión Alexa, enciende mi televisión Alexa, apaga mi televisión

Y así es como lo probaremos. Esperamos que decir cualquiera de esos comandos despierte nuestro código e ingrese esa devolución de llamada, donde podemos hacer lo que queramos con él.

Agregue el comando IR

Ahora que estamos recibiendo el comando, es hora de manejarlo… encendiendo/apagando nuestro televisor. Así que esto será todo: wifi, emulador wemo e IR, todo junto. Mi televisor es un LG, así que busqué la secuencia apropiada para encender/apagar y la envié a través de la función sendNEC de nuestra biblioteca IR (LG usa el protocolo NEC). la codificación/descodificación de IR es un tema aparte en sí mismo, en el que un mensaje se codifica en la modulación de una señal; es una especificación de tiempos, marcas y espacios muy precisos. Cada fabricante tiende a usar su propio protocolo propietario para los comandos y con diferentes tiempos; es bastante interesante, y puede profundizar en el código fuente de esa biblioteca de IR, buscar en Google, etc. Pero para nuestra comodidad, nuestra biblioteca de IR se ocupa de los detalles de todo eso.

¿Tu televisor no es un LG? Simplemente busque en Google el código correcto. Aquí está el comando para televisores Sony (advertencia: no probado):

 irSend.sendSony(0xa90, 12);

Si realmente quiere hacerlo usted mismo, puede configurar un receptor IR, apuntar su control remoto (o cualquier transmisor IR) hacia él y decodificar los códigos que está enviando; Sin embargo, ese es un tutorial diferente.

Prueba de extremo a extremo

• Coloca tu Alexa en cualquier lugar donde pueda oírte.
• Coloque su ESP8266 con el diodo IR conectado, dentro del alcance del control remoto del televisor.
• Di "Alexa, descubre dispositivos". Espere a que informe el éxito (debería haber descubierto al menos un dispositivo).
• Di "Alexa, enciende mi televisor" o "Alexa, apaga mi televisor".

Alexa debe entender su comando (como un comando inteligente, no dirigido a una habilidad específica), buscar un dispositivo local para manejarlo y enviar el comando al dispositivo (su ESP8266). Su dispositivo debería recibirlo y enviar el comando del control remoto al televisor. Puede ver su diodo a través de la cámara de un teléfono móvil para asegurarse de que esté emitiendo.

Dado que el código IR para apagar un televisor es el mismo que el código para encenderlo, no importa si da la orden de "encender" o "apagar". Es el mismo código y cambia el estado. Si el televisor está apagado, debe encenderse, y si está encendido, debe apagarse.

Solución de problemas

¿Estás conectado al Wifi?

¿Ingresó el nombre de usuario/contraseña correctos en los valores de variable correctos?

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

¿Recibes un mensaje de falla, o algún error a través del puerto de depuración serial, al conectarte al Wifi?

¿Está encendido su Wifi y puede conectarse a través de cualquier otro medio ordinario?

¿Tu dispositivo está siendo descubierto por Alexa?

Alexa enviará solicitudes para descubrir dispositivos cuando digas "Alexa, descubre dispositivos".

Su Alexa debe estar configurado y configurado correctamente y conectado a la misma red Wifi que su ESP8266.

Mira en Fauxmo.h. Ver la función Fauxmo::handle(). Este es el primer código que se ejecutará una vez que el ESP8266 haya escuchado la llamada. Ponga mensajes de depuración para ver si hay algún código después

 if (len > 0) {

Esta corriendo. Si no es así, entonces no se está recibiendo el comando. Si es así, parece que el comando se recibe, pero no se maneja correctamente. Siga el código desde allí para averiguar cuál es el problema.

¿Tiene muchos otros dispositivos detectables en su red? Demasiados pueden hacer que el descubrimiento se ejecute más lentamente, o incluso que a veces falle.

¿Su dispositivo está recibiendo el comando?

Cuando emite el comando "Alexa, enciende mi televisor", la ejecución debe ingresar a su WemoCallbackHandler::handleCallback handler (en el archivo WemoCallbackHandler.h). Si no lo ha hecho, intente generar algún mensaje de depuración para asegurarse de que se active cuando emita su comando. Además, intente asegurarse de que Alexa conozca su dispositivo diciendo "Alexa, descubre dispositivos" antes de emitir su comando. Este paso supone que la detección de dispositivos se ha realizado correctamente.

¿Está emitiendo el diodo IR?

Como se describió anteriormente, cuando crea que su dispositivo debería estar emitiendo, apunte la cámara de su teléfono móvil hacia él y mire el diodo a través de la cámara. Aunque en la vida real no puedes ver nada, a través de la cámara debería aparecer como una luz normal encendiéndose y parpadeando. Si ves esto, entonces está emitiendo... algo.

¿Está invertida la señal IR?

Su diodo IR puede estar cableado de tal manera que la señal se invierta esencialmente. Tenga paciencia conmigo en mi explicación, ya que no soy un tipo de electrónica o cableado, pero el resultado de un cableado incorrecto del diodo será que la luz IR estará ENCENDIDA de manera predeterminada, pero APAGADA cuando la biblioteca IRSend intente encender en. Si este es el caso, su luz IR debería estar encendida (visible a través de la cámara) de manera predeterminada, después de que se ejecute el código setup() , pero antes de que suceda cualquier otra cosa. Si tuviera que comentar todo el código dentro de loop() , debería ver que permanece encendido continuamente.

Para ver más claramente cómo solucionar esto, vaya a la carpeta library/IRemoteESP8266/src del código del tutorial. Ver el constructor:

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

El argumento “invertido” y la lógica que lo maneja es de lo que estamos hablando. Si su cableado está invertido, la solución más fácil es hacer un pequeño cambio en el código para permitir esto (en lugar de volver a cablear... pero, por supuesto, puede hacerlo si lo prefiere). Simplemente cambie esta línea en AlexaTvRemote.ino:

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

para

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

¿Tiene el código y el comando de control remoto correctos?

Si todo lo demás parece ir bien, pero el televisor simplemente no obedece, es muy probable que algo esté mal con el código IR. Pruebe distintas llamadas a funciones en esa interfaz de biblioteca IR (p. ej., sendLG , sendPanasonic , sendSharp , etc.) o asegúrese de que la que está utilizando coincida con su hardware. Es muy poco probable que el hardware de su televisor no sea compatible con esa biblioteca, pero supongo que es técnicamente posible.

Asegúrese de que el código que está enviando sea el correcto para su hardware. Es posible que tengas que investigar un poco en Google para encontrar el correcto. Si todo lo demás falla, siempre existe la opción de detectar el código que emite su control remoto en funcionamiento cuando presiona el botón de encendido, pero ese es un tutorial diferente y requiere un hardware diferente.

Terminando

Esperemos que todo te haya salido bien. Si es así (y tal vez incluso si no), esta ha sido una buena manera de aprender varios temas a la vez:

• Alexa
• Programación integrada
• El chip ESP8266
• El IDE de Arduino

También, por supuesto, tiene la quizás ligera comodidad de poder encender/apagar su televisor mediante un comando de voz.

¿Por qué el Hack?

¿Por qué es esto un truco y no parte de la API básica para Alexa? Después de aprender a desarrollar mi primera habilidad de Alexa, todo lo que realmente quería saber era "¿cómo puedo enviar un comando directamente desde Alexa a otro dispositivo en la red?" Es una pena que Amazon no haya expuesto una API completa para la comunicación entre el dispositivo Alexa y otros objetos en la red local, sin pasar por el paradigma de "habilidad" o "hogar inteligente" (donde todo debe enviarse a AWS antes de hacer nada), pero simplemente no lo han hecho.

Intenta llevarlo más lejos

Pruebe un conjunto de comandos de control remoto para controlar más completamente su televisor, como cambiar el canal y controlar el volumen. Pruebe los límites del chip al ver cuántos comandos diferentes puede escuchar en un ESP8266 (pista: el número apenas supera los dos dígitos, sin una programación muy inteligente). Si es bueno con el hardware, intente controlar otros dispositivos que no sean a través de IR, conectándolos directamente a los chips ESP8266; como la iluminación y tal. ¡Reinventa el wemo!