Introdução ao desenvolvimento de IoT: um tutorial do Arduino ESP8266

O objetivo deste tutorial do ESP8266 Arduino é familiarizar-se com a programação embarcada com Arduino em um chip que se tornou super popular entre a comunidade maker (e desenvolvedores em geral) por sua acessibilidade e facilidade de uso no espaço IoT. O tutorial também suja as mãos com o Alexa usando um “hack” não oficial para fazer com que o Alexa faça nossos lances em casa (essa técnica não é para uso em produção, apenas para demonstração em casa). Tente isso em casa, mas não no trabalho.

A beleza dessa técnica é que podemos usá-la em nossas próprias casas para fazer com que o Alexa automatize quase literalmente qualquer coisa que funcione com eletricidade. Como um bônus adicional, temos uma visão da programação embarcada com Arduino, uma habilidade que talvez não seja tão comum entre os programadores convencionais hoje em dia. Finalmente, começamos a trabalhar com o popular chip ESP8266, um favorito entre os do-it-yourself; é um pequeno chip incrível com capacidade de executar todos os tipos de coisas, com um chip Wifi integrado que precisaremos para este projeto. É o que permitirá que o dispositivo Alexa e o chip se comuniquem diretamente.

Apenas algumas informações sobre a programação do Alexa: O modelo de programação de “habilidades” do Alexa funciona assim:

• Você fala com seu Alexa.
• Alexa roteia seu discurso de volta para a nuvem da Amazon.
• O comando de fala é roteado para uma “habilidade” do Alexa (um programa que roda na nuvem da Amazon).

A “habilidade” do Alexa assume o controle do comando; normalmente, isso resulta em uma resposta sendo enviada de volta ao dispositivo Alexa, fazendo com que ele diga algo ao usuário em resposta. No caso do Alexa IoT, o comando é roteado para uma “sombra de dispositivo” na nuvem da Amazon, que no final resulta em uma resposta sendo enviada para algum outro dispositivo em sua casa. Estamos ignorando tudo isso com nosso hack. Queremos fazer o dispositivo Alexa falar diretamente com nosso chip ESP8266, dentro de nossa casa, sem enviar nada para a nuvem e vice-versa. Queremos que o Alexa envie uma solicitação diretamente ao nosso ESP8266, apenas dentro e fora de nossa rede wifi doméstica.

Nosso hack não é realmente um segredo. Vamos fazer nosso ESP8266 “emular” um Wemo Belkin, um aparelho que possui uma licença especial com a Amazon permitindo que ele se comunique diretamente com o aparelho Alexa, contornando toda aquela comunicação na nuvem da Amazon descrita acima.

Fingindo ser um Wemo, nosso ESP8266 tem o privilégio de poder receber comandos diretamente do Alexa.

Plano básico para o nosso tutorial ESP8266 Arduino

• Ouça no ESP8266 o dispositivo Alexa enviando sondas na rede wifi local para dispositivos compatíveis e responda a essas sondas dizendo "Sou um Wemo".
• Uma vez confiável pelo dispositivo Alexa, ouça mais comandos do referido dispositivo. Lide com eles enviando códigos IR através do transmissor IR, ligando/desligando nossa TV.

Requisitos de hardware

Para concluir este tutorial, você precisará obter alguns itens por conta própria, todos fáceis de obter.

• Qualquer dispositivo Alexa. Eu desenvolvi este tutorial com um Alexa Dot. O tutorial funcionará com um simulador de eco? Pode! (mas não testei). Experimente se você estiver se sentindo aventureiro (ou frugal). O dispositivo Alexa custa dinheiro de bolso, mas o uso do Echosim é gratuito.
• Um chip ESP8266. Eles custavam apenas alguns dólares no momento da redação deste artigo. Você pode obtê-los no Ebay, ou em qualquer loja de ferragens bem abastecida online.
• Um diodo IR (infravermelho). Você precisará conectar isso ao seu chip ESP8266, e isso você mesmo terá que fazer. Para este projeto, precisamos apenas dos recursos de envio; não nos importamos com o recebimento de IR. Certifique-se de conectar o diodo ao GND e produzir 0 para que este tutorial funcione. (Se você fizer isso de outra forma, tudo bem, mas você também terá que ser responsável por modificar o código do tutorial de acordo. Este link pode ajudá-lo. Esteja ciente de que devido ao esquema de numeração usado no ESP8266, pino 0 pode ser rotulado como "D3".
• Um adaptador serial que de um lado é USB (para conectar ao seu computador dev) e do outro lado se encaixa no chip ESP8266.
• Uma rede Wi-Fi local para a qual você sabe o nome de usuário e a senha.

Ferramentas de software do Arduino

• Arduíno IDE. Existem versões para todos os principais sistemas operacionais, incluindo Windows. Este tutorial foi desenvolvido na versão Ubuntu, mas já instalei e usei o Arduino no Windows também, sem problemas.
• A biblioteca de desenvolvimento ESP8266 para Arduino.
• Motoristas. Felizmente, os drivers para o seu adaptador provavelmente devem ser plug & play, portanto, não são necessários drivers adicionais.

Configurando tudo

• Instale o Arduino IDE.
• Instale a biblioteca ESP8266 usando o Boards Manager.

Para instalar a biblioteca ESP8266 usando o Boards Manager:

• No Arduino IDE, abra Arquivo -> Preferências .
• Insira este URL em “URL do Gerenciador de Placas Adicionais”: http://arduino.esp8266.com/stable/package_esp8266com_index.json
• Clique OK

• Vá para o Gerenciador de Placas ( Ferramentas -> Placa: [placa atual] -> Gerenciador de Placas ).

• Na caixa de texto "filtro", digite "ESP8266".
• Você deve obter uma entrada para “esp8266” agora que adicionou o gerenciador de placas adicional. Escolha-o e clique em “instalar”.

• Espere um pouco — leva algum tempo para baixar tudo.
• Reinicie o IDE do Arduino.
• Abra Tools -> Board: e, desta vez, role para baixo até “Generic ESP8266 Module” e selecione-o.

Adicionando bibliotecas de terceiros

O Arduino oferece muitas maneiras diferentes de adicionar bibliotecas externas ao seu projeto, ou “Sketch”, como eles chamam. Para manter as coisas o mais simples possível, para este tutorial, vamos apenas explicar o mais rápido, que é simplesmente copiar pastas. Precisaremos adicionar exatamente duas bibliotecas externas para que o tutorial funcione: IRemoteESP8266 e https://github.com/me-no-dev/ESPAsyncTCP.

• No código do tutorial no GitHub, localize o diretório “libraries”.
• No diretório de instalação raiz do Arduino (por exemplo, C:\Program Files\Arduino), localize o subdiretório “libraries”.
• Copie o diretório IRemoteESP8266 do diretório “libraries” do tutorial para o diretório “libraries” do Arduino.
• Copie o diretório ESPAsyncTCP do diretório “libraries” do tutorial para o diretório “libraries” do Arduino.
• Reinicie o IDE do Arduino.

Agora as bibliotecas para transmissão IR e TCP assíncrono estão incluídas no projeto.

Configurações

A imagem abaixo mostra as configurações típicas, que funcionam para mim e meu hardware, mas podem variar para cada usuário. Você pode tentar as configurações abaixo, mas é possível que precise ajustá-las com base em seu chip e adaptador específicos. O meu é nodemcu, por exemplo, então tive que mudar o método de reset de “ck” (o padrão) para “nodemcu”. Além disso, defina “debug port” para “serial” para que você possa usar o depurador serial. O meu é uma configuração muito típica, então você pode usar minhas configurações como base; Estou apenas dizendo que não se surpreenda se você tiver que mexer com eles para que o processo de compilação e flash funcione.

Prove sua configuração com um ESP8266 Hello World

Os projetos do Arduino começam com um arquivo .ino. O arquivo .ino define dois pontos de entrada: setup e loop. Para o nosso “hello world”, vamos acender uma pequena luz, no ESP8266, só para verificar se nosso 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 e atualizar o código

Compilar e fazer flash são passos fáceis, se sua configuração até agora estiver correta. Para compilar sem piscar, basta ir em Sketch -> Verify/Compile no menu Arduino.

Para fazer o flash do código no chip e também compilar, selecione Sketch -> Upload no menu Arduino.

Se o flash for bem-sucedido, você verá uma exibição de progresso de 0% a 100%, durante o qual o LED em seu chip provavelmente piscará ou piscará.

Para testar se a depuração serial está funcionando:

• Primeiro, certifique-se de que a porta de depuração esteja definida como Serial ( Tools -> Debug port ).
• Depois que seu código terminar de piscar no chip, selecione Tools -> Serial Monitor .

Saída do depurador serial após uma inicialização bem-sucedida:

Ótimo, então isso funciona; em seguida, queremos verificar nossa saída IR. Vamos enviar um sinal através do nosso transmissor IR e verificar se o sinal está chegando.

Vamos fazer uso de uma biblioteca Arduino IR existente para nos ajudar. Uma das grandes coisas sobre o Arduino é como é fácil encaixar bibliotecas e módulos dentro e fora. Muito refrescante para um framework C++!

Basta seguir as instruções no arquivo README desse repositório Git para instalar no Arduino.

Este código apenas pisca o transmissor IR repetidamente. O IR é invisível ao olho humano, mas há uma dica profissional para testá-lo; execute este código, verifique (através do depurador) se ele está sendo executado em seu chip e abra a câmera do seu dispositivo móvel. Olhe diretamente para a lâmpada do diodo IR através de sua câmera . Se estiver funcionando, você deverá ver a lâmpada ligando e desligando visivelmente. Você também pode tentar isso com qualquer controle remoto em funcionamento (por exemplo, um controle remoto de TV padrão). O código a seguir deve fazer com que a lâmpada IR comece a piscar a cada 0,5 segundo. Na verdade, ele envia o comando de ligar/desligar LG, então ele pode realmente desligar e ligar sua TV LG se estiver por perto.

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

Comece o tutorial do ESP8266

Se tudo funcionou até agora, acho que podemos ficar satisfeitos que nosso equipamento básico e configuração estão funcionando, e estamos prontos para começar a parte essencial do tutorial.

Conecte-se ao Wi-Fi

Primeiro, vamos precisar nos conectar ao wifi local. O código abaixo tentará se conectar ao Wifi e relatará sucesso na conexão (através do depurador serial). No exemplo de código, não se esqueça de substituir o valor de myWifiSsid pelo nome de usuário da sua rede wifi e substituir o valor de myWifiPassword pela senha correta.

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

Execute o servidor Wemo

Conectado? Boa. Agora estamos chegando ao cerne do projeto: o servidor Wemo.

Meu próprio emulador Wemo está incluído nos arquivos de origem deste tutorial. Agora, você pode pesquisar no Google e encontrar um emulador Wemo mais simples. Você pode encontrar um que seja escrito usando menos código e que seja fácil de entender. De qualquer forma, sinta-se à vontade para examinar, experimentar, escrever o seu próprio, etc. Tudo isso faz parte de tornar este tutorial seu.

O raciocínio por trás do meu é que ele usa ESPAsyncTCP. Por que isso é bom? Bem, existem tantos servidores (ou dispositivos) que você pode executar no ESP8266 usando esse método antes que ele comece a se tornar não confiável, no sentido de que o Alexa começará a perder dispositivos (não os encontrando), os comandos serão descartados e o desempenho torna-se lento. Acho que esse número é maximizado pelo uso da biblioteca ESPAsyncTCP.

Sem ele, descobri que a falta de confiabilidade se aproxima de 10 a 12 dispositivos; com ele, acho que esse número sobe para cerca de 16. Caso você queira expandir este tutorial e explorar os limites do que o chip pode fazer, recomendo usar minha versão. Se você quiser ver uma versão mais simples apenas para seu próprio entendimento, sinta-se à vontade para pesquisar “wemo emulator Arduino” no Google; você deve encontrar uma série de exemplos.

Agora, temos que instalar a biblioteca ESPAsyncTCP. Instale-o exatamente como fizemos com a biblioteca IR; vá para a página do Git e siga as instruções.

Esta biblioteca também está incluída no meu código de exemplo esp8266 arduino. Aqui está apenas o código para abrir a conexão wifi, ouvir a solicitação de descoberta do Alexa e tratá-la retornando uma resposta “I am 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é-teste

Teste o que temos até agora (wifi e emulador), executando-o com Alexa. Este tutorial pressupõe que seu dispositivo Alexa esteja configurado e instalado em sua casa.

Descoberta de teste:

Diga a Alexa: “Alexa, descubra dispositivos”.

Isso fará com que o Alexa transmita uma solicitação UDP em sua rede wifi local, procurando por Wemos e outros dispositivos compatíveis. Este pedido deve ser recebido na chamada para wemulator->listen(); na função loop(). Isso, por sua vez, o roteia para o método handleUDPPacket(*) do Wemulator. Uma resposta é enviada no método nextUDPResponse() . Observe o conteúdo dessa resposta:

 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 é o código que diz ao Alexa “Sou um Wemo (Belkin), como posso ajudá-lo?” Uma vez que o Alexa recebe essa resposta, ele sabe e lembra que futuros comandos de casa inteligente podem ser roteados para este dispositivo.

A saída do depurador serial neste ponto deve se parecer com a imagem abaixo. Quando terminar de descobrir, o Alexa informará verbalmente que “descobriu [N] dispositivos” em sua rede.

Na função setup() , observe o seguinte trecho:

 new WemoCallbackHandler(&commandReceived)

Este é o retorno de chamada onde capturaremos os comandos do Alexa. Seu corpo é definido em WemoCallbackHandler.h (WemoCallbackHandler::handleCallback). Depois de capturar um comando do Alexa, podemos fazer o que quisermos com ele. Nas linhas anteriores, configuramos possíveis comandos que podem ser usados, com estas linhas de código:

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

Então estes são 4 “servidores” ou ouvintes separados que estamos rodando no chip. Isso configura a capacidade de dizer qualquer um dos seguintes comandos para o Alexa:

Alexa, ligar a tv Alexa, desligar a tv Alexa, ligar a televisão Alexa, desligar a televisão Alexa, ligar minha tv Alexa, desligar minha tv Alexa, ligar minha televisão Alexa, desligar minha televisão

E é assim que vamos testá-lo. Esperamos que dizer qualquer um desses comandos desperte nosso código e insira esse retorno de chamada, onde podemos fazer o que quisermos com ele.

Adicione o comando IR

Agora que estamos recebendo o comando, é hora de lidar com isso… ligando/desligando nossa TV. Então, isso será tudo – wifi, emulador wemo e IR – tudo junto. Minha TV é uma LG, então procurei a sequência apropriada para ligar/desligar e enviei através da função sendNEC da nossa biblioteca IR (a LG usa o protocolo NEC). A codificação/decodificação IR é um assunto separado em si, em que uma mensagem é codificada na modulação de um sinal; é uma especificação de tempos, marcas e espaços muito precisos. Cada fabricante tende a usar seu próprio protocolo proprietário para comandos, e com tempos diferentes; é bem interessante, e você pode ir mais fundo examinando o código-fonte dessa biblioteca de IR, pesquisando no Google, etc.

Sua TV não é LG? Basta pesquisar no Google o código correto. Aqui está o comando para TVs Sony (ressalva: não testado):

 irSend.sendSony(0xa90, 12);

Se você quiser realmente fazer você mesmo, você pode configurar um receptor IR, apontar seu controle remoto (ou qualquer transmissor IR) para ele e decodificar os códigos que ele está enviando; esse é um tutorial diferente, no entanto.

Teste de ponta a ponta

• Coloque seu Alexa em qualquer lugar onde ele possa ouvi-lo.
• Coloque seu ESP8266 com diodo IR conectado, dentro do alcance do controle remoto da TV.
• Diga "Alexa, descubra dispositivos". Aguarde até que ele relate o sucesso (deve ter descoberto pelo menos um dispositivo).
• Diga "Alexa, ligue minha TV" ou "Alexa, desligue minha TV".

O Alexa deve entender seu comando (como um comando smarthome, não direcionado a uma habilidade específica), procurar um dispositivo local para lidar com ele e enviar o comando para o dispositivo (seu ESP8266). Seu dispositivo deve recebê-lo e enviar o comando do controle remoto para a TV. Você pode visualizar seu diodo através de uma câmera de celular para garantir que ele esteja emitindo.

Como o código IR para desligar uma TV é o mesmo que o código para ligá-la, não importa se você der o comando para ligar ou desligar. É o mesmo código e alterna o estado. Se a TV estiver desligada, ela deve ligar, e se estiver ligada, ela deve desligar.

Solução de problemas

Você está conectado ao Wi-Fi?

Você digitou o nome de usuário/senha corretos nos valores de variável corretos?

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

Você está recebendo uma mensagem de falha ou algum erro na porta serial de depuração ao conectar-se ao Wifi?

O seu Wifi está ligado e você pode se conectar a ele por qualquer outro meio comum?

Seu dispositivo está sendo descoberto pelo Alexa?

O Alexa enviará solicitações para descobrir dispositivos quando você disser "Alexa, descubra dispositivos".

Seu Alexa deve estar configurado e configurado corretamente e conectado à mesma rede Wifi do seu ESP8266.

Procure em Fauxmo.h. Veja a função Fauxmo::handle(). Este é o primeiro código que será executado assim que o ESP8266 ouvir a chamada. Coloque mensagens de depuração para ver se algum código depois

 if (len > 0) {

está correndo. Se não estiver, o comando não está sendo recebido. Se for, parece que o comando está sendo recebido, mas não tratado corretamente. Siga o código de lá para descobrir qual é o problema.

Você tem muitos outros dispositivos detectáveis ​​em sua rede? Muitos podem fazer com que a descoberta seja executada mais lentamente ou, às vezes, até falhe.

Seu dispositivo está recebendo o comando?

Quando você emite o comando “Alexa, ligue minha TV”, a execução deve estar entrando em seu WemoCallbackHandler::handleCallback handler (no arquivo WemoCallbackHandler.h). Se você não tiver feito isso, tente enviar alguma mensagem de depuração para garantir que ela seja acionada quando você emitir seu comando. Além disso, tente garantir que o Alexa conheça seu dispositivo dizendo "Alexa, descubra dispositivos" antes de emitir seu comando. Esta etapa pressupõe que a descoberta do dispositivo foi bem-sucedida.

O diodo IR está emitindo?

Conforme descrito anteriormente, quando você achar que seu dispositivo deveria estar emitindo, aponte a câmera do seu celular para ele e olhe para o diodo através da câmera. Embora na vida real você não possa ver nada, através da câmera deve aparecer como uma luz normal acendendo e piscando. Se você vir isso, então está emitindo... alguma coisa.

O sinal IR está invertido?

Seu diodo IR pode ser conectado de tal forma que o sinal seja essencialmente invertido. Por favor, tenha paciência comigo na minha explicação, pois não sou um cara de eletrônica ou fiação, mas o resultado da fiação errada do diodo será que a luz IR estará LIGADA por padrão, mas DESLIGADA quando a biblioteca IRSend pretender ligar ligado. Se este for o caso, sua luz IR deve estar acesa (visível através da câmera) por padrão, após a execução do código setup() , mas antes que qualquer outra coisa aconteça. Se você comentar todo o código dentro de loop() , deverá vê-lo permanecer continuamente.

Para ver mais claramente como corrigir isso, vá para a pasta library/IRemoteESP8266/src do código do tutorial. Veja o construtor:

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

O argumento “invertido” e a lógica que o trata é do que estamos falando. Se sua fiação for invertida, a solução mais fácil é fazer uma pequena alteração no código para permitir isso (em vez de religar ... mas se é claro que você pode fazer isso se preferir). Basta alterar esta linha no AlexaTvRemote.ino:

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

para

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

Você tem o código e o comando de controle remoto corretos?

Se tudo estiver indo bem, mas a TV não estiver obedecendo, é provável que algo esteja errado com o código IR. Tente chamadas de função diferentes nessa interface de biblioteca IR (por exemplo, sendLG , sendPanasonic , sendSharp , etc.), ou certifique-se de que a que você está usando corresponde ao seu hardware. É muito improvável que o hardware da sua TV não seja suportado por essa biblioteca, mas acho que é tecnicamente possível.

Certifique-se de que o código que você está enviando seja o correto para o seu hardware. Você pode ter que fazer algumas pesquisas no google para encontrar o caminho certo. Se tudo mais falhar, sempre há a opção de detectar o código que emite do seu controle remoto de trabalho, quando você pressiona o botão Liga / Desliga - mas esse é um tutorial diferente e requer hardware diferente.

Empacotando

Espero que tudo tenha dado certo para você. Se sim (e talvez mesmo se não), esta foi uma boa maneira de aprender vários assuntos ao mesmo tempo:

• Alexa
• Programação incorporada
• O chip ESP8266
• A IDE do Arduino

Além disso, é claro, você tem a conveniência de poder ligar / desligar sua TV por comando de voz.

Por que o Hack?

Por que isso é um hack e não faz parte da API básica do Alexa? Depois de aprender a desenvolver minha primeira habilidade do Alexa, tudo o que eu realmente queria saber era “como posso enviar um comando diretamente do Alexa para outro dispositivo na rede?” É uma pena que a Amazon não tenha exposto uma API completa para comunicação entre o dispositivo Alexa e outros objetos na rede local, sem passar pelo paradigma “skill” ou “smart-home” (onde tudo deve ser enviado para AWS antes de fazer qualquer coisa), mas eles simplesmente não têm.

Tente ir além

Experimente um conjunto de comandos de controle remoto para controlar melhor sua TV, como alterar o canal e controlar o volume. Teste os limites do chip vendo quantos comandos diferentes você pode ouvir em um ESP8266 (dica: o número mal quebra dois dígitos, sem uma programação muito inteligente). Se você é bom com hardware, tente controlar outros dispositivos não através de IR, conectando-os diretamente aos chips ESP8266; como iluminação e tal. Reinvente o wemo!