Inizia con lo sviluppo IoT: un tutorial Arduino ESP8266

L'obiettivo di questo tutorial Arduino ESP8266 è familiarizzare con la programmazione embedded con Arduino su un chip che è diventato molto popolare tra la comunità dei maker (e gli sviluppatori in generale) per la sua accessibilità e facilità d'uso nello spazio IoT. Il tutorial ci sporca anche le mani con Alexa usando un "hack" non ufficiale per convincere Alexa a eseguire le nostre offerte in casa (questa tecnica non è pensata per l'uso in produzione, solo per la dimostrazione a casa). Provalo a casa, ma non al lavoro.

Il bello di questa tecnica è che possiamo usarla nelle nostre case per fare in modo che Alexa automatizzi quasi letteralmente tutto ciò che funziona con l'elettricità. Come bonus aggiuntivo, otteniamo un'idea della programmazione embedded con Arduino, un'abilità che forse non è così comune tra i programmatori tradizionali di questi tempi. Infine, possiamo lavorare con il popolare chip ESP8266, uno dei preferiti dai fai-da-te; è un piccolo chip straordinario con la capacità di eseguire ogni sorta di cose, con un chip Wi-Fi integrato di cui avremo bisogno per questo progetto. È ciò che consentirà al dispositivo Alexa e al chip di comunicare direttamente tra loro.

Solo alcune informazioni sulla programmazione di Alexa: il modello di programmazione delle "competenze" di Alexa funziona in questo modo:

• Tu parli con la tua Alexa.
• Alexa indirizza il tuo discorso fino al cloud di Amazon.
• Il comando vocale viene instradato a una "abilità" di Alexa (un programma che viene eseguito nel cloud di Amazon).

L'"abilità" di Alexa assume la gestione del comando; normalmente si traduce in una risposta che viene rispedita al dispositivo Alexa, facendogli dire qualcosa all'utente in risposta. Nel caso di Alexa IoT, il comando viene instradato a un "device shadow" sul cloud di Amazon, che alla fine si traduce in una risposta inviata a qualche altro dispositivo nella tua casa. Stiamo bypassando tutto questo con il nostro hack. Vogliamo che il dispositivo Alexa parli direttamente con il nostro chip ESP8266, all'interno della nostra casa, senza inviare nulla al cloud e viceversa. Vogliamo che Alexa invii direttamente una richiesta al nostro ESP8266, solo all'interno della nostra rete wifi domestica.

Il nostro hack non è davvero un segreto. Faremo in modo che il nostro ESP8266 "emuli" un Wemo Belkin, un dispositivo che ha una licenza speciale con Amazon che gli consente di comunicare direttamente con il dispositivo Alexa, bypassando tutte quelle comunicazioni cloud Amazon descritte sopra.

Fingendo di essere un Wemo, il nostro ESP8266 gode del privilegio di poter ricevere comandi direttamente dall'Alexa.

Piano di base per il nostro tutorial Arduino ESP8266

• Ascolta su ESP8266 per il dispositivo Alexa che invia sonde sulla rete Wi-Fi locale per dispositivi compatibili e rispondi a queste sonde dicendo "Sono un Wemo".
• Una volta considerato attendibile dal dispositivo Alexa, ascolta ulteriori comandi da detto dispositivo. Gestiscili inviando codici IR tramite il trasmettitore IR, accendendo/spegnendo la nostra TV.

Requisiti hardware

Per completare questo tutorial, avrai bisogno di ottenere alcuni oggetti da solo, tutti facili da ottenere.

• Qualsiasi dispositivo Alexa. Ho sviluppato questo tutorial con un Alexa Dot. Il tutorial funzionerà con un simulatore Echo? Potrebbe! (Ma non l'ho testato). Fai un tentativo se ti senti avventuroso (o frugale). Il dispositivo Alexa costa una paghetta, ma l'uso di Echosim è gratuito.
• Un chip ESP8266. Costano solo pochi dollari al momento della stesura di questo articolo. Puoi ottenerli su Ebay o praticamente in qualsiasi negozio di ferramenta ben fornito online.
• Un diodo IR (infrarossi). Dovrai collegarlo al tuo chip ESP8266 e dovrai farlo da solo. Per questo progetto, abbiamo solo bisogno delle capacità di invio; non ci interessa la ricezione di IR. Assicurati di collegare il diodo a GND e di uscita 0 affinché questo tutorial funzioni. (Se lo fai in qualsiasi altro modo, va bene, ma dovrai anche essere responsabile della modifica del codice del tutorial di conseguenza. Questo link potrebbe aiutarti. Tieni presente che, a causa dello schema di numerazione utilizzato su ESP8266, pin 0 può essere etichettato come "D3".
• Un adattatore seriale che da un lato è USB (da collegare al computer di sviluppo) e l'altro lato si inserisce nel chip ESP8266.
• Una rete wifi locale di cui conosci nome utente e password.

Strumenti software Arduino

• Arduino IDE. Esistono versioni per tutti i principali sistemi operativi, incluso Windows. Questo tutorial è stato sviluppato sulla versione Ubuntu, ma ho installato e utilizzato Arduino anche su Windows, nessun problema.
• La libreria di sviluppo ESP8266 per Arduino.
• Autisti. Fortunatamente, i driver per l'adattatore dovrebbero essere molto probabilmente plug & play, quindi non sono necessari driver aggiuntivi.

Impostare tutto

• Installa Arduino IDE.
• Installa la libreria ESP8266 usando Boards Manager.

Per installare la libreria ESP8266 utilizzando Boards Manager:

• Nell'IDE di Arduino, apri File -> Preferenze .
• Inserisci questo URL in "URL di gestione schede aggiuntive": http://arduino.esp8266.com/stable/package_esp8266com_index.json
• Fare clic su OK

• Vai a Boards Manager ( Strumenti -> Board: [board corrente] -> Boards Manager ).

• Nella casella di testo "filtro", digita "ESP8266".
• Dovresti ottenere una voce per "esp8266" ora che hai aggiunto il gestore di schede aggiuntivo. Sceglilo e fai clic su "installa".

• Aspetta un po': ci vuole del tempo per scaricare tutto.
• Riavvia il tuo IDE Arduino.
• Apri Strumenti -> Scheda: e, questa volta, scorri verso il basso fino a "Modulo ESP8266 generico" e selezionalo.

Aggiunta di librerie di terze parti

Arduino offre molti modi diversi per aggiungere librerie esterne al tuo progetto, o "Sketch", come lo chiamano. Per mantenere le cose il più semplici possibile, per questo tutorial, ci limiteremo a spiegare più velocemente, ovvero copiare semplicemente le cartelle. Dovremo aggiungere esattamente due librerie esterne affinché il tutorial funzioni: IRemoteESP8266 e https://github.com/me-no-dev/ESPAsyncTCP.

• Nel codice del tutorial in GitHub, trova la directory "librerie".
• Nella directory di installazione principale di Arduino (ad es. C:\Programmi\Arduino), trova la sottodirectory "librerie".
• Copia la directory IRemoteESP8266 dalla directory "librerie" del tutorial nella directory "librerie" di Arduino.
• Copia la directory ESPAsyncTCP dalla directory "librerie" del tutorial nella directory "librerie" di Arduino.
• Riavvia l'IDE Arduino.

Ora le librerie per la trasmissione IR e il TCP asincrono sono incluse nel progetto.

Impostazioni

L'immagine seguente mostra le impostazioni tipiche, che funzionano per me e il mio hardware ma possono variare per ogni utente. Puoi provare le impostazioni di seguito, ma è possibile che tu debba regolarle in base al tuo particolare chip e adattatore. Il mio è nodemcu, ad esempio, quindi ho dovuto cambiare il metodo di ripristino da "ck" (l'impostazione predefinita) a "nodemcu". Inoltre, imposta "porta di debug" su "seriale" in modo da poter utilizzare il debugger seriale. La mia è una configurazione molto tipica, quindi puoi usare le mie impostazioni come base; Sto solo dicendo che non sorprenderti se devi pasticciare con loro per far funzionare il processo di compilazione e flash.

Dimostra la tua configurazione con un ESP8266 Hello World

I progetti Arduino iniziano con un file .ino. Il file .ino definisce due punti di ingresso: setup e loop. Per il nostro "hello world", accenderemo una piccola luce, sull'ESP8266, solo per verificare che il nostro codice funzioni.

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

Compila e flash il codice

Compilare e flashare sono semplici passaggi, se la tua configurazione finora è corretta. Per compilare senza flash, vai su Sketch -> Verifica/Compila dal menu Arduino.

Per eseguire il flashing del codice sul chip e per compilare, selezionare Schizzo -> Carica dal menu Arduino.

Se il flash ha esito positivo, vedrai un display di avanzamento passare da 0% a 100%, durante questo periodo il LED sul tuo chip molto probabilmente lampeggerà o lampeggerà.

Per verificare che il debug seriale funzioni:

• Per prima cosa assicurati che la porta di debug sia impostata su Serial ( Strumenti -> Porta di debug ).
• Dopo che il tuo codice ha finito di lampeggiare sul chip, seleziona Strumenti -> Monitor seriale .

Output del debugger seriale dopo un avvio riuscito:

Ottimo, quindi funziona; successivamente, vogliamo verificare la nostra uscita IR. Inviamo un segnale attraverso il nostro trasmettitore IR e verifichiamo che il segnale arrivi.

Utilizzeremo una libreria IR Arduino esistente per aiutarci. Una delle grandi cose di Arduino è la facilità con cui è possibile inserire e rimuovere librerie e moduli. Molto rinfrescante per un framework C++!

Segui semplicemente le istruzioni nel file README del repository Git per l'installazione in Arduino.

Questo codice fa lampeggiare ripetutamente il trasmettitore IR. L'IR è invisibile all'occhio umano, ma c'è un consiglio per testarlo; esegui questo codice, verifica (tramite il debugger) che sia in esecuzione sul tuo chip, quindi apri la fotocamera del tuo dispositivo mobile. Guarda direttamente la lampadina del diodo IR attraverso la tua fotocamera . Se funziona, dovresti vedere la lampadina accendersi e spegnersi visibilmente. Puoi provarlo anche con qualsiasi telecomando funzionante (ad esempio, un telecomando TV standard). Il codice seguente dovrebbe far sì che la lampadina IR inizi a lampeggiare ogni 0,5 secondi. In realtà invia il comando di accensione/spegnimento LG, quindi potrebbe effettivamente spegnere e accendere la tua TV LG se si trova nelle vicinanze.

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

Inizia il tutorial ESP8266

Se tutto ha funzionato finora, penso che possiamo essere soddisfatti del fatto che la nostra attrezzatura di base e la configurazione funzionino e siamo pronti per iniziare la carne del tutorial.

Connettiti al Wi-Fi

Innanzitutto, dovremo connetterci al wifi locale. Il codice seguente tenterà di connettersi al Wi-Fi e segnala il successo della connessione (tramite il debugger seriale). Nell'esempio di codice, non dimenticare di sostituire il valore di myWifiSsid con il nome utente della tua rete wifi e di sostituire il valore di myWifiPassword con la password corretta.

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

Esegui il server Wemo

Collegato? Buona. Ora arriviamo al cuore del progetto: il server Wemo.

Il mio emulatore Wemo è incluso nei file sorgente di questo tutorial. Ora puoi cercare su Google e trovare un emulatore Wemo più semplice. Puoi trovarne uno scritto usando meno codice e che è facile da capire. Con tutti i mezzi, sentiti libero di esaminare, sperimentare, scrivere il tuo, ecc. Fa tutto parte del rendere questo tutorial tuo.

Il ragionamento alla base del mio è che utilizza ESPAsyncTCP. Perché va bene? Bene, ci sono solo così tanti server (o dispositivi) che puoi eseguire su ESP8266 usando questo metodo prima che inizi a diventare inaffidabile, nel senso che Alexa inizierà a perdere i dispositivi (non trovarli), i comandi verranno eliminati e le prestazioni diventa lento. Trovo che questo numero sia massimizzato dall'uso della libreria ESPAsyncTCP.

Senza di esso, ho riscontrato che l'inaffidabilità si insinuava in circa 10-12 dispositivi; con esso, trovo che il numero arrivi a circa 16. Nel caso in cui desideri espandere questo tutorial ed esplorare i limiti di ciò che il chip può fare, ti consiglio di utilizzare la mia versione. Se vuoi vedere una versione più semplice solo per la tua comprensione, sentiti libero di cercare "wemo emulator Arduino" su Google; dovresti trovare una miriade di esempi.

Ora dobbiamo installare la libreria ESPAsyncTCP. Installalo proprio come abbiamo fatto con la libreria IR; vai alla pagina Git e segui le istruzioni.

Questa libreria è inclusa anche nel mio codice di esempio arduino esp8266. Ecco solo il codice per aprire la connessione wifi, ascoltare la richiesta di rilevamento di Alexa e gestirla restituendo una risposta "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(); } }

Pre-test

Testa ciò che abbiamo finora (wifi ed emulatore), eseguendolo con Alexa. Questo tutorial presuppone che il tuo dispositivo Alexa sia configurato e installato a casa tua.

Scoperta del test:

Dì ad Alexa "Alexa, scopri i dispositivi".

Ciò farà sì che Alexa trasmetta una richiesta UDP sulla tua rete wifi locale, scansionando Wemos e altri dispositivi compatibili. Questa richiesta dovrebbe essere ricevuta nella chiamata a wemulator->listen(); nella funzione loop(). Questo a sua volta lo instrada al metodo handleUDPPacket(*) di Wemulator. Una risposta viene inviata nel metodo nextUDPResponse() . Nota il contenuto di quella risposta:

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

Questo è il codice che dice ad Alexa "Sono un Wemo (Belkin), come posso aiutarti?" Una volta ricevuta questa risposta, Alexa sa e ricorda che i futuri comandi della casa intelligente potrebbero essere instradati a questo dispositivo.

L'output del debugger seriale a questo punto dovrebbe essere simile all'immagine seguente. Al termine della scoperta, Alexa ti dirà verbalmente che ha "scoperto [N] dispositivi" sulla tua rete.

Nella funzione setup() , nota il seguente snippet:

 new WemoCallbackHandler(&commandReceived)

Questa è la richiamata in cui cattureremo i comandi da Alexa. Il suo corpo è definito in WemoCallbackHandler.h (WemoCallbackHandler::handleCallback). Dopo aver acquisito un comando da Alexa, possiamo fare ciò che vogliamo con esso. Nelle righe precedenti, abbiamo impostato i possibili comandi che possono essere utilizzati, con queste righe di codice:

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

Quindi questi sono 4 "server" o ascoltatori separati che stiamo eseguendo sul chip. Questo imposta la possibilità di pronunciare uno qualsiasi dei seguenti comandi ad Alexa:

Alexa, accendi la tv Alexa, spegni la tv Alexa, accendi la televisione Alexa, spegni la televisione Alexa, accendi la mia tv Alexa, spegni la mia tv Alexa, accendi la mia televisione Alexa, spegni la mia televisione

Ed è così che lo testeremo. Ci aspettiamo che pronunciando uno qualsiasi di questi comandi riattivi il nostro codice e inserisca quella richiamata, dove possiamo fare ciò che ci piace con esso.

Aggiungi il comando IR

Ora che stiamo ricevendo il comando, è il momento di gestirlo... accendendo/spegnendo la nostra TV. Quindi questo sarà tutto - wifi, emulatore wemo e IR - tutto messo insieme. La mia TV è un LG, quindi ho cercato la sequenza appropriata per l'accensione/spegnimento e l'ho inviata tramite la funzione sendNEC della nostra libreria IR (LG utilizza il protocollo NEC). La codifica/decodifica IR è di per sé un argomento separato, in cui un messaggio è codificato nella modulazione di un segnale; è una specificazione di tempi, segni e spazi molto precisi. Ogni produttore tende ad utilizzare un proprio protocollo proprietario per i comandi, e con tempistiche diverse; è piuttosto interessante e puoi scavare più a fondo esaminando il codice sorgente di quella libreria IR, cercando su Google, ecc. Ma per nostra comodità, i dettagli di tutto ciò che si prende cura di noi dalla nostra libreria IR.

La tua TV non è un LG? Basta cercare su Google il codice corretto. Ecco il comando per i televisori Sony (avvertenza: non testato):

 irSend.sendSony(0xa90, 12);

Se vuoi fare davvero il fai-da-te, puoi configurare un ricevitore IR, puntare il tuo telecomando (o qualsiasi trasmettitore IR) su di esso e decodificare i codici che sta inviando; questo è un tutorial diverso, però.

Prova dall'inizio alla fine

• Posiziona il tuo Alexa ovunque possa sentirti.
• Posiziona il tuo ESP8266 con il diodo IR collegato, all'interno della portata del telecomando del televisore.
• Dì "Alexa, scopri i dispositivi". Attendi che segnali il successo (dovrebbe aver rilevato almeno un dispositivo).
• Dì "Alexa, accendi la TV" o "Alexa, spegni la TV".

Alexa dovrebbe comprendere il tuo comando (come comando smarthome, non diretto a un'abilità specifica), cercare un dispositivo locale per gestirlo e inviare il comando al dispositivo (il tuo ESP8266). Il tuo dispositivo dovrebbe riceverlo e inviare il comando del telecomando alla TV. Puoi visualizzare il tuo diodo attraverso la fotocamera di un telefono cellulare per assicurarti che stia emettendo.

Poiché il codice IR per spegnere un televisore è lo stesso del codice per accenderlo, non importa se dai il comando per accendere o spegnere. È lo stesso codice e cambia lo stato. Se la TV è spenta, dovrebbe accendersi e, se accesa, dovrebbe spegnersi.

Risoluzione dei problemi

Sei connesso al Wifi?

Hai inserito il nome utente/password corretti nei valori delle variabili corretti?

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

Ricevi un messaggio di errore o un errore tramite la porta seriale di debug durante la connessione al Wi-Fi?

Il tuo Wifi è acceso e puoi connetterti con qualsiasi altro mezzo ordinario?

Il tuo dispositivo viene rilevato da Alexa?

Alexa invierà richieste per scoprire dispositivi quando dici "Alexa, scopri dispositivi".

Il tuo Alexa deve essere configurato e configurato correttamente e connesso alla stessa rete Wi-Fi del tuo ESP8266.

Guarda in Fauxmo.h. Vedere la funzione Fauxmo::handle(). Questo è il primo codice che verrà eseguito una volta che l'ESP8266 avrà ascoltato la chiamata. Inserisci i messaggi di debug per vedere se c'è del codice dopo

 if (len > 0) {

è in esecuzione. In caso contrario, il comando non viene ricevuto. In tal caso, sembra che il comando venga ricevuto, ma non gestito correttamente. Segui il codice da lì per scoprire qual è il problema.

Hai molti altri dispositivi rilevabili sulla tua rete? Troppi possono causare un'esecuzione più lenta della scoperta o addirittura un errore.

Il tuo dispositivo sta ricevendo il comando?

Quando emetti il ​​comando "Alexa, accendi la TV", l'esecuzione dovrebbe entrare nel tuo WemoCallbackHandler::handleCallback handler (nel file WemoCallbackHandler.h). Se non l'hai fatto, prova a generare un messaggio di debug per assicurarti che si attivi quando emetti il ​​tuo comando. Inoltre, prova ad assicurarti che Alexa conosca il tuo dispositivo dicendo "Alexa, scopri dispositivi" prima di impartire il comando. Questo passaggio presuppone che il rilevamento del dispositivo sia riuscito.

Il diodo IR emette?

Come descritto in precedenza, quando pensi che il tuo dispositivo dovrebbe emettere, punta la fotocamera del tuo cellulare verso di esso e guarda il diodo attraverso la fotocamera. Anche se nella vita reale non puoi vedere nulla, attraverso la fotocamera dovrebbe apparire come una normale luce che si accende e lampeggia. Se vedi questo, allora sta emettendo... qualcosa.

Il segnale IR è invertito?

Il tuo diodo IR potrebbe essere cablato in modo tale che il segnale sia essenzialmente invertito. Per favore, abbi pazienza con me sulla mia spiegazione, poiché non sono un esperto di elettronica o cablaggio, ma il risultato di un cablaggio errato del diodo sarà che la luce IR sarà accesa per impostazione predefinita, ma spenta quando la libreria IRSend intende accendersi su. In questo caso, la tua luce IR dovrebbe essere accesa (visibile attraverso la fotocamera) per impostazione predefinita, dopo l'esecuzione del codice setup() , ma prima che accada qualsiasi altra cosa. Se dovessi commentare tutto il codice all'interno di loop() , dovresti vederlo rimanere continuamente.

Per vedere più chiaramente come risolvere questo problema, vai nella cartella library/IRemoteESP8266/src del codice tutorial. Vedi il costruttore:

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

L'argomento "invertito" e la logica che lo gestisce è ciò di cui stiamo parlando. Se il tuo cablaggio è invertito, la soluzione più semplice è apportare una piccola modifica al codice per consentirlo (piuttosto che ricablare ... ma se ovviamente puoi farlo se preferisci). Basta cambiare questa riga in AlexaTvRemote.ino:

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

a

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

Hai il giusto codice e comando del telecomando?

Se tutto il resto sembra andare bene, ma la TV semplicemente non obbedisce, è probabilmente abbastanza probabile che qualcosa non va con il codice IR. Prova diverse chiamate di funzione su quell'interfaccia della libreria IR (ad esempio, sendLG , sendPanasonic , sendSharp , ecc.), o assicurati che quella che stai usando corrisponda al tuo hardware. È molto improbabile che l'hardware della tua TV non sia supportato da quella libreria, ma suppongo che sia tecnicamente possibile.

Assicurati che il codice che stai inviando sia quello giusto per il tuo hardware. Potrebbe essere necessario scavare un po' su google per trovare quello giusto. Se tutto il resto fallisce, c'è sempre la possibilità di rilevare il codice emesso dal tuo telecomando funzionante, quando premi il pulsante di accensione, ma questo è un tutorial diverso e richiede hardware diverso.

Avvolgendo

Speriamo che tutto abbia funzionato per te. Se è così (e forse anche in caso contrario), questo è stato un buon modo per tagliarsi i denti su più argomenti contemporaneamente:

• Alessia
• Programmazione incorporata
• Il chip ESP8266
• L'IDE Arduino

Inoltre, ovviamente, hai la forse leggera comodità di poter accendere/spegnere la tua tv tramite comando vocale.

Perché l'hack?

Perché questo è un hack e non fa parte dell'API di base per Alexa? Dopo aver appreso come sviluppare la mia prima abilità di Alexa, tutto ciò che volevo davvero sapere era "come posso semplicemente inviare un comando direttamente dall'Alexa a un altro dispositivo sulla rete?" Peccato che Amazon non abbia esposto una vera e propria API per la comunicazione tra il dispositivo Alexa e altri oggetti sulla rete locale, senza passare per il paradigma “skill” o “smart-home” (in cui tutto deve essere inviato ad AWS prima di fare qualsiasi cosa), ma semplicemente non l'hanno fatto.

Prova a portarlo oltre

Prova una suite di comandi del telecomando per controllare in modo più completo la tua TV, come cambiare canale e controllare il volume. Metti alla prova i limiti del chip vedendo quanti comandi diversi puoi ascoltare su un ESP8266 (suggerimento: il numero rompe a malapena le doppie cifre, senza una programmazione molto intelligente). Se sei bravo con l'hardware, prova a controllare altri dispositivi non tramite IR, collegandoli direttamente ai chip ESP8266; come l'illuminazione e così via. Reinventa il wemo!