Începeți cu dezvoltarea IoT: un tutorial ESP8266 Arduino

Obiectivul acestui tutorial ESP8266 Arduino este de a se familiariza cu programarea încorporată cu Arduino pe un cip care a devenit super popular în rândul comunității producătorilor (și dezvoltatorilor în general) pentru accesibilitatea și ușurința sa de utilizare în spațiul IoT. De asemenea, tutorialul ne murdărește mâinile cu Alexa folosind un „hack” neoficial pentru a-l determina pe Alexa să ne facă licitarea acasă (această tehnică nu este destinată utilizării în producție, ci doar pentru demonstrații acasă). Încercați acest lucru acasă, dar nu la serviciu.

Frumusețea acestei tehnici este că o putem folosi în propriile noastre case pentru a face Alexa să automatizeze aproape literalmente orice funcționează cu electricitate. Ca un bonus suplimentar, obținem o perspectivă asupra programarii încorporate cu Arduino, o abilitate care poate nu este atât de comună printre programatorii mainstream în zilele noastre. În cele din urmă, ne apucăm de lucrul cu popularul cip ESP8266, un favorit printre cei care fac do-it-yourself; este un mic cip uimitor, cu capacitatea de a rula tot felul de lucruri, cu un cip Wifi încorporat de care vom avea nevoie pentru acest proiect. Este ceea ce va permite dispozitivului Alexa și cipul să comunice direct unul cu celălalt.

Doar câteva informații despre programarea Alexa: modelul de programare „aptitudini” Alexa funcționează astfel:

• Vorbești cu Alexa ta.
• Alexa vă direcționează discursul până în cloud-ul Amazon.
• Comanda de vorbire este direcționată către o „aptitudine” Alexa (un program care rulează în cloud-ul Amazon).

„Abilitatea” Alexa preia gestionarea comenzii; în mod normal, rezultă că un răspuns este trimis înapoi către dispozitivul Alexa, determinându-l să spună ceva utilizatorului ca răspuns. În cazul Alexa IoT, comanda este direcționată către o „umbră a dispozitivului” pe cloud-ul Amazon, care în cele din urmă duce la trimiterea unui răspuns către un alt dispozitiv din casa ta. Ocolim toate acestea cu hack-ul nostru. Vrem să facem dispozitivul Alexa să vorbească direct cu cipul nostru ESP8266, în interiorul casei noastre, fără a trimite nimic în cloud și înapoi. Dorim ca Alexa să trimită direct o solicitare către ESP8266, numai peste și în interiorul rețelei noastre wifi de acasă.

Hackul nostru nu este cu adevărat un secret. Vom face ca ESP8266-ul nostru să „emuleze” un Wemo Belkin, un dispozitiv care are o licență specială cu Amazon, care îi permite să comunice direct cu dispozitivul Alexa, ocolind toate acele comunicări în cloud Amazon descrise mai sus.

Pretinzând că este un Wemo, ESP8266 nostru se bucură de privilegiul de a putea primi comenzi direct de la Alexa.

Plan de bază pentru tutorialul nostru ESP8266 Arduino

• Ascultați pe ESP8266 dispozitivul Alexa care trimite sonde în rețeaua wifi locală pentru dispozitive compatibile și răspundeți la aceste sonde spunând „Sunt un Wemo”.
• Odată ce dispozitivul Alexa a primit încredere, ascultați comenzi suplimentare de la dispozitivul respectiv. Gestionați-le trimițând coduri IR prin transmițătorul IR, pornind/oprind televizorul.

Cerințe hardware

Pentru a finaliza acest tutorial, va trebui să obțineți unele articole pe cont propriu, toate fiind ușor de obținut.

• Orice dispozitiv Alexa. Am dezvoltat acest tutorial cu un punct Alexa. Va funcționa tutorialul cu un simulator Echo? S-ar putea! (Dar nu l-am testat). Încearcă-l dacă te simți aventuros (sau cumpătat). Dispozitivul Alexa costă bani de buzunar, dar utilizarea Echosim este gratuită.
• Un cip ESP8266. Ele costă aproximativ doar câțiva USD la momentul scrierii acestui articol. Le puteți obține pe Ebay sau aproape orice magazin de hardware bine aprovizionat online.
• O diodă IR (infraroșu). Va trebui să conectați acest lucru la cipul ESP8266 și va trebui să faceți acest lucru singur. Pentru acest proiect avem nevoie doar de capabilitățile de trimitere; nu ne pasă de recepția IR. Asigurați-vă că conectați dioda la GND și ieșiți 0 pentru ca acest tutorial să funcționeze. (Dacă o faci în orice alt mod, este în regulă, dar va trebui să fii responsabil și pentru modificarea codului tutorialului în consecință. Acest link te poate ajuta. Fii conștient de faptul că, datorită schemei de numerotare utilizată pe ESP8266, pinul 0 poate fi etichetat ca „D3”.
• Un adaptor serial care pe de o parte este USB (pentru a se conecta la computerul dvs. de dezvoltare), iar cealaltă parte se potrivește în cipul ESP8266.
• O rețea wifi locală la care cunoașteți numele de utilizator și parola.

Instrumente software Arduino

• Arduino IDE. Există versiuni pentru toate sistemele de operare majore, inclusiv Windows. Acest tutorial a fost dezvoltat pe versiunea Ubuntu, dar am instalat și folosit Arduino și pe Windows, fără probleme.
• Biblioteca de dezvoltare ESP8266 pentru Arduino.
• Șoferii. Din fericire, driverele pentru adaptorul dvs. ar trebui, cel mai probabil, să fie plug & play, deci nu sunt necesare drivere suplimentare.

Configurarea Totului

• Instalați Arduino IDE.
• Instalați biblioteca ESP8266 utilizând Boards Manager.

Pentru a instala biblioteca ESP8266 folosind Boards Manager:

• În Arduino IDE, deschideți Fișier -> Preferințe .
• Introduceți această adresă URL în „Adresa URL a managerului plăcilor suplimentare”: http://arduino.esp8266.com/stable/package_esp8266com_index.json
• Faceți clic pe OK

• Accesați Managerul de forumuri ( Instrumente -> Tablou: [tableaua curentă] -> Manager de forumuri ).

• În caseta de text „filtru”, tastați „ESP8266”.
• Ar trebui să obțineți o intrare pentru „esp8266” acum că ați adăugat managerul de plăci suplimentar. Alegeți-l și faceți clic pe „instalați”.

• Așteptați puțin – este nevoie de ceva timp pentru a descărca totul.
• Reporniți IDE-ul dvs. Arduino.
• Deschideți Tools -> Board: și, de data aceasta, derulați în jos la „Generic ESP8266 Module” și selectați-l.

Adăugarea de biblioteci terță parte

Arduino oferă multe moduri diferite de a adăuga biblioteci externe la proiectul dvs. sau „Sketch”, așa cum îl numesc ei. Pentru a menține lucrurile cât mai simple posibil, pentru acest tutorial, vom lua doar cel mai rapid de explicat, și anume să copiați folderele. Va trebui să adăugăm exact două biblioteci externe pentru ca tutorialul să funcționeze: IRemoteESP8266 și https://github.com/me-no-dev/ESPAsyncTCP.

• În codul tutorial din GitHub, găsiți directorul „biblioteci”.
• În directorul de instalare rădăcină pentru Arduino (de exemplu, C:\Program Files\Arduino), găsiți subdirectorul „biblioteci”.
• Copiați directorul IRemoteESP8266 din directorul „biblioteci” al tutorialului în directorul „biblioteci” al Arduino.
• Copiați directorul ESPAsyncTCP din directorul „biblioteci” al tutorialului în directorul „biblioteci” al Arduino.
• Reporniți IDE-ul Arduino.

Acum bibliotecile pentru transmiterea IR și TCP asincron sunt incluse în proiect.

Setări

Imaginea de mai jos arată setările tipice, care funcționează pentru mine și hardware-ul meu, dar pot varia pentru fiecare utilizator. Puteți încerca setările de mai jos, dar există șansa să fie necesar să le ajustați în funcție de cip și adaptor. Al meu este nodemcu, de exemplu, așa că a trebuit să schimb metoda de resetare de la „ck” (implicit) la „nodemcu”. De asemenea, setați „portul de depanare” la „serial”, astfel încât să puteți utiliza depanatorul serial. A mea este o configurație foarte tipică, așa că puteți folosi setările mele ca bază; Spun doar să nu fii surprins dacă trebuie să te încurci cu ei pentru ca procesul de compilare și flash să funcționeze.

Demonstrați-vă configurația cu un ESP8266 Hello World

Proiectele Arduino încep cu un fișier .ino. Fișierul .ino definește două puncte de intrare: setare și buclă. Pentru „hello world”, vom aprinde o mică lumină, pe ESP8266, doar pentru a verifica dacă codul nostru funcționează.

 //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ți și flashați codul

Compilarea și flash-ul sunt pași simpli, dacă configurația dvs. de până acum este corectă. Pentru a compila fără a clipi, trebuie doar să accesați Sketch -> Verify/Compile din meniul Arduino.

Pentru a afișa codul pe cip, precum și pentru a compila, selectați Schiță -> Încărcare din meniul Arduino.

Dacă blițul reușește, veți vedea că un afișaj de progres merge de la 0% la 100%, timp în care LED-ul de pe cip va clipi sau va clipi cel mai probabil.

Pentru a testa că depanarea în serie funcționează:

• Mai întâi asigurați-vă că portul de depanare este setat la Serial ( Instrumente -> Port de depanare ).
• După ce codul s-a terminat să clipească pe cip, selectați Instrumente -> Monitor serial .

Ieșirea depanatorului serial după o pornire cu succes:

Grozav, așa că funcționează; în continuare, dorim să verificăm ieșirea IR. Să trimitem un semnal prin transmițătorul nostru IR și să verificăm dacă semnalul ajunge.

Vom folosi o bibliotecă IR Arduino existentă pentru a ne ajuta. Unul dintre lucrurile grozave despre Arduino este cât de ușor este să introduceți și să scoateți biblioteci și module. Foarte revigorant pentru un framework C++!

Doar urmați instrucțiunile din fișierul README al acelui repo Git pentru a instala în Arduino.

Acest cod pur și simplu clipește transmițătorul IR în mod repetat. IR este invizibil pentru ochiul uman, dar există un sfat pro pentru a-l testa; rulați acest cod, verificați (prin intermediul depanatorului) dacă rulează pe cip, apoi deschideți camera dispozitivului mobil. Priviți direct la becul diodei IR prin camera dvs. Dacă funcționează, ar trebui să vezi că becul se aprinde și se stinge vizibil. Puteți încerca acest lucru și cu orice telecomandă funcțională (de exemplu, o telecomandă TV standard). Următorul cod ar trebui să facă ca becul IR să înceapă să clipească la fiecare 0,5 secunde. De fapt, trimite comanda de pornire/oprire LG, așa că poate opri și porni televizorul LG dacă este în apropiere.

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

Începeți tutorialul ESP8266

Dacă totul a funcționat până acum, cred că putem fi mulțumiți că echipamentul și configurația noastră de bază funcționează și suntem gata să începem cu adevărat tutorialul.

Conectați-vă la Wifi

În primul rând, va trebui să ne conectăm la Wi-Fi local. Codul de mai jos va încerca să se conecteze la Wifi și raportează succesul la conectare (prin depanatorul serial). În exemplul de cod, nu uitați să înlocuiți valoarea myWifiSsid cu numele de utilizator al rețelei dvs. wifi și să înlocuiți valoarea myWifiPassword cu parola corectă.

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

Rulați serverul Wemo

Conectat? Bun. Acum ajungem la miezul proiectului: serverul Wemo.

Propriul meu emulator Wemo este inclus în fișierele sursă pentru acest tutorial. Acum, puteți căuta pe Google și puteți găsi un emulator Wemo mai simplu. Puteți găsi unul care este scris folosind mai puțin cod și care este ușor de înțeles. În orice caz, simțiți-vă liber să examinați, să experimentați, să scrieți pe al dvs. etc. Toate acestea fac parte din crearea acestui tutorial.

Raționamentul din spatele meu este că folosește ESPAsyncTCP. De ce este bine asta? Ei bine, există doar atâtea servere (sau dispozitive) pe care le puteți rula pe ESP8266 folosind această metodă înainte de a începe să devină nesigură, în sensul că Alexa va începe să lipsească dispozitive (nu le găsește), comenzile vor fi renunțate și performanța. devine lent. Găsesc că acest număr este maximizat prin utilizarea bibliotecii ESPAsyncTCP.

Fără el, am descoperit că nefiabilitatea se strecoară la aproximativ 10-12 dispozitive; cu el, găsesc că numărul crește la aproximativ 16. În cazul în care doriți să extindeți acest tutorial și să explorați limitele a ceea ce poate face cipul, vă recomand să utilizați versiunea mea. Dacă doriți să vedeți o versiune mai simplă doar pentru propria înțelegere, nu ezitați să căutați „wemo emulator Arduino” pe Google; ar trebui să găsiți o mulțime de exemple.

Acum, trebuie să instalăm biblioteca ESPAsyncTCP. Instalați-l așa cum am făcut cu biblioteca IR; accesați pagina Git și urmați instrucțiunile.

Această bibliotecă este inclusă și în codul meu exemplu arduino esp8266. Iată doar codul pentru a deschide conexiunea wifi, a asculta cererea de descoperire Alexa și a o gestiona returnând un răspuns „Sunt 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-testare

Testați ce avem până acum (wifi și emulator), rulând-o cu Alexa. Acest tutorial presupune că dispozitivul dvs. Alexa este configurat și instalat în casa dvs.

Descoperirea testului:

Spune-i lui Alexa: „Alexa, descoperă dispozitive”.

Acest lucru va determina Alexa să difuzeze o solicitare UDP în rețeaua dvs. wifi locală, scanând Wemos și alte dispozitive compatibile. Această solicitare ar trebui să fie primită în apelul la wemulator->listen(); în funcția loop(). Aceasta, la rândul său, îl direcționează către metoda handleUDPPacket(*) a Wemulator. Un răspuns este trimis în metoda nextUDPResponse() . Observați conținutul acelui răspuns:

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

Acesta este codul care îi spune lui Alexa „Sunt un Wemo (Belkin), cum te pot ajuta?” Odată ce Alexa primește acest răspuns, știe și își amintește că viitoarele comenzi smart-home pot fi direcționate către acest dispozitiv.

Ieșirea depanatorului serial în acest moment ar trebui să arate ca imaginea de mai jos. Când ați terminat de descoperit, Alexa vă va spune verbal că a „descoperit [N] dispozitive” în rețeaua dvs.

În funcția setup() , rețineți următorul fragment:

 new WemoCallbackHandler(&commandReceived)

Acesta este apelul înapoi în care vom captura comenzile de la Alexa. Corpul său este definit în WemoCallbackHandler.h (WemoCallbackHandler::handleCallback). Odată ce am capturat o comandă de la Alexa, putem face ce ne place cu ea. În rândurile anterioare, am configurat posibile comenzi care pot fi utilizate, cu aceste linii de cod:

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

Deci acestea sunt 4 „servere” separate sau ascultători pe care îi rulăm pe cip. Aceasta setează capacitatea de a spune oricare dintre următoarele comenzi către Alexa:

Alexa, porniți televizorul Alexa, opriți televizorul Alexa, porniți televizorul Alexa, opriți televizorul Alexa, porniți televizorul Alexa, închideți televizorul Alexa, porniți televizorul Alexa, opriți televizorul

Și așa o vom testa. Ne așteptăm ca rostirea oricăreia dintre aceste comenzi să ne trezească codul și să introducem acel callback, unde putem face ce ne place cu el.

Adăugați comanda IR

Acum că primim comanda, este timpul să o gestionăm prin... pornirea/oprirea televizorului. Deci, acesta va fi totul - wifi, emulator wemo și IR - toate adunate. Televizorul meu este un LG, așa că am căutat secvența potrivită pentru pornire/oprire și am trimis-o prin funcția sendNEC a bibliotecii noastre IR (LG folosește protocolul NEC). Codificarea/decodificarea IR este un subiect separat în sine, în care un mesaj este codificat în modularea unui semnal; este o specificație a timpurilor, a marcajelor și a spațiilor foarte precise. Fiecare producător tinde să folosească propriul protocol proprietar pentru comenzi și cu momente diferite; este destul de interesant și poți să sapi mai profund căutând codul sursă al acelei biblioteci IR, google, etc. Dar, spre comoditatea noastră, detaliile a tot ceea ce ne sunt îngrijite de biblioteca noastră IR.

Televizorul tău nu este un LG? Doar căutați pe Google codul corect. Iată comanda pentru televizoarele Sony (avertisment: netestat):

 irSend.sendSony(0xa90, 12);

Dacă doriți să obțineți cu adevărat do-it-yourself, puteți configura un receptor IR, puteți îndrepta telecomanda (sau orice transmițător IR) spre el și puteți decoda codurile pe care le trimite; acesta este un tutorial diferit, totuși.

Test de la capăt la capăt

• Puneți Alexa oriunde vă poate auzi.
• Plasați ESP8266 cu o diodă IR atașată, în raza de acțiune a telecomenzii televizorului.
• Spune „Alexa, descoperă dispozitive”. Așteptați să raporteze succesul (ar fi trebuit să descopere cel puțin un dispozitiv).
• Spune „Alexa, pornește-mi televizorul” sau „Alexa, închide-mi televizorul”.

Alexa ar trebui să vă înțeleagă comanda (ca o comandă smarthome, care nu este direcționată către o anumită abilitate), să caute un dispozitiv local care să o gestioneze și să trimită comanda către dispozitiv (ESP8266). Dispozitivul dvs. ar trebui să îl primească și să trimită comanda telecomenzii către televizor. Puteți vizualiza dioda printr-o cameră a telefonului mobil pentru a vă asigura că emite.

Deoarece codul IR pentru a opri un televizor este același cu codul pentru a-l porni, nu contează dacă dați comanda pentru a porni sau a opri. Este același cod și comută starea. Dacă televizorul este oprit, ar trebui să pornească, iar dacă este pornit, ar trebui să se oprească.

Depanare

Ești conectat la Wifi?

Ați introdus numele de utilizator/parola corecte în valorile variabilelor corecte?

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

Primiți un mesaj de eroare sau vreo eroare prin portul serial de depanare când vă conectați la Wifi?

Wifi-ul dvs. este pornit și vă puteți conecta la el prin alte mijloace obișnuite?

Dispozitivul dvs. este descoperit de Alexa?

Alexa va trimite solicitări de a descoperi dispozitive atunci când spui „Alexa, descoperă dispozitive”.

Alexa trebuie să fie configurată și configurată corect și conectată la aceeași rețea Wifi ca ESP8266.

Uită-te în Fauxmo.h. Vezi funcția Fauxmo::handle(). Acesta este primul cod care va rula odată ce ESP8266 a auzit apelul. Introduceți mesaje de depanare pentru a vedea dacă există vreun cod după

 if (len > 0) {

rulează. Dacă nu este, atunci comanda nu este primită. Dacă este, atunci se pare că comanda este primită, dar nu este gestionată corect. Urmați codul de acolo pentru a afla care este problema.

Aveți multe alte dispozitive care pot fi descoperite în rețea? Prea multe pot face ca descoperirea să ruleze mai lent sau chiar să eșueze uneori.

Dispozitivul dvs. primește comanda?

Când lansați comanda „Alexa, porniți televizorul”, execuția ar trebui să fie introdusă în gestionarea dvs. WemoCallbackHandler::handleCallback handler (în fișierul WemoCallbackHandler.h). Dacă nu ați făcut acest lucru, încercați să afișați un mesaj de depanare acolo pentru a vă asigura că se declanșează când lansați comanda. De asemenea, încercați să vă asigurați că Alexa știe despre dispozitivul dvs. spunând „Alexa, descoperă dispozitivele” înainte de a emite comanda. Acest pas presupune că descoperirea dispozitivului a reușit.

Emite dioda IR?

După cum s-a descris mai înainte, când credeți că dispozitivul dvs. ar trebui să emită, îndreptați camera telefonului mobil spre el și priviți dioda prin cameră. Deși în viața reală nu poți vedea nimic, prin cameră ar trebui să apară ca o lumină normală care se aprinde și clipește. Dacă vezi asta, atunci emite... ceva.

Semnalul IR este inversat?

Dioda dvs. IR poate fi conectată în așa fel încât semnalul să fie în esență inversat. Vă rugăm să suportați explicația mea, deoarece nu sunt un tip cu electronică sau cablare, dar rezultatul unei cablari greșite a diodei va fi că lumina IR va fi PORNITĂ în mod implicit, dar va fi OPRIT atunci când biblioteca IRSend intenționează să se aprindă. el pe. Dacă acesta este cazul, lumina dvs. IR ar trebui să fie aprinsă (vizibilă prin cameră) în mod implicit, după rularea codului setup() , dar înainte de a se întâmpla orice altceva. Dacă ar fi să comentați tot codul din interiorul loop() , ar trebui să vedeți că rămâne activ în mod continuu.

Pentru a vedea mai clar cum să remediați acest lucru, accesați folderul biblioteci/IRemoteESP8266/src al codului tutorial. Vezi constructorul:

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

Argumentul „inversat” și logica care îl gestionează este despre care vorbim. Dacă cablarea dvs. este inversată, cea mai ușoară soluție este să faceți o mică modificare a codului pentru a permite acest lucru (mai degrabă decât recablarea... dar dacă, desigur, puteți face asta dacă preferați). Doar schimbați această linie în AlexaTvRemote.ino:

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

la

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

Aveți codul de telecomandă și comanda potrivite?

Dacă totul pare să meargă bine, dar televizorul pur și simplu nu se supune, este probabil destul de probabil să fie ceva în neregulă cu codul IR. Încercați diferite apeluri de funcție pe acea interfață de bibliotecă IR (de exemplu, sendLG , sendPanasonic , sendSharp , etc.) sau asigurați-vă că cel pe care îl utilizați se potrivește cu hardware-ul dvs. Este foarte puțin probabil ca hardware-ul televizorului tău să nu fie acceptat de acea bibliotecă, dar cred că este posibil din punct de vedere tehnic.

Asigurați-vă că codul pe care îl trimiteți este cel potrivit pentru hardware-ul dvs. S-ar putea să trebuiască să caute pe google pentru a-l găsi pe cel potrivit. Dacă toate celelalte nu reușesc, există întotdeauna opțiunea de a detecta codul care emite de la telecomanda care funcționează, atunci când apăsați butonul de pornire, dar acesta este un tutorial diferit și necesită hardware diferit.

Încheierea

Sper că totul a funcționat pentru tine. Dacă da (și poate chiar dacă nu), aceasta a fost o modalitate bună de a vă tăia dinții pe mai multe subiecte simultan:

• Alexa
• Programare încorporată
• Cipul ESP8266
• IDE-ul Arduino

De asemenea, bineînțeles, aveți și poate ușor confortul de a vă putea porni/opri televizorul prin comandă vocală.

De ce Hack?

De ce este acesta un hack și nu face parte din API-ul de bază pentru Alexa? După ce am învățat cum să-mi dezvolt prima abilitate Alexa, tot ce voiam să știu cu adevărat era „cum pot trimite o comandă direct de la Alexa la alt dispozitiv din rețea?” Este păcat că Amazon nu a expus un API cu drepturi depline pentru comunicarea dintre dispozitivul Alexa și alte obiecte din rețeaua locală, fără a trece prin paradigma „skill” sau „smart-home” (în care totul trebuie trimis la AWS înainte de a face ceva), dar pur și simplu nu au făcut-o.

Încercați să o duceți mai departe

Încercați o suită de comenzi de telecomandă pentru a vă controla mai complet televizorul, cum ar fi schimbarea canalului și controlul volumului. Testați limitele cipului, văzând câte comenzi diferite puteți asculta pe un singur ESP8266 (indiciu: numărul abia încalcă două cifre, fără o programare foarte inteligentă). Dacă sunteți bun cu hardware-ul, încercați să controlați alte dispozitive nu prin IR, conectându-le direct la cipurile ESP8266; precum iluminatul și așa. Reinventează wemo!