เริ่มต้นกับการพัฒนา IoT: บทช่วยสอน Arduino ESP8266

วัตถุประสงค์ของบทช่วยสอน Arduino ESP8266 นี้คือการทำความคุ้นเคยกับการเขียนโปรแกรมแบบฝังตัวกับ Arduino บนชิปที่ได้รับความนิยมอย่างสูงในหมู่ผู้ผลิต (และนักพัฒนาโดยทั่วไป) สำหรับการเข้าถึงและใช้งานง่ายในพื้นที่ IoT บทช่วยสอนนี้ทำให้มือของเราสกปรกกับ Alexa โดยใช้ "แฮ็ค" ที่ไม่เป็นทางการเพื่อให้ Alexa ทำการประมูลในบ้าน (เทคนิคนี้ไม่ได้มีไว้สำหรับใช้ในการผลิต แต่สำหรับการสาธิตที่บ้านเท่านั้น) ลองทำที่บ้าน แต่ไม่ใช่ที่ทำงาน

ความงามของเทคนิคนี้คือเราสามารถใช้มันในบ้านของเราเองเพื่อทำให้ Alexa ทำงานโดยอัตโนมัติแทบทุกอย่างที่ใช้ไฟฟ้า เป็นโบนัสเพิ่มเติม เราได้รับข้อมูลเชิงลึกเกี่ยวกับการเขียนโปรแกรมแบบฝังด้วย Arduino ซึ่งเป็นทักษะที่อาจไม่ธรรมดาในหมู่โปรแกรมเมอร์กระแสหลักในทุกวันนี้ ในที่สุด เราก็ได้ทำงานกับชิป ESP8266 ยอดนิยม ซึ่งเป็นที่ชื่นชอบในหมู่ผู้ที่ทำด้วยตัวเอง มันเป็นชิปตัวเล็กที่น่าทึ่งพร้อมความสามารถในการเรียกใช้ทุกสิ่งด้วยชิป Wifi ในตัวที่เราจะต้องมีสำหรับโปรเจ็กต์นี้ ซึ่งจะทำให้อุปกรณ์ Alexa และชิปสามารถสื่อสารกันได้โดยตรง

พื้นหลังบางส่วนในการเขียนโปรแกรม Alexa: โมเดลการเขียนโปรแกรม "ทักษะ" ของ Alexa ทำงานดังนี้:

• คุณพูดกับ Alexa ของคุณ
• Alexa กำหนดเส้นทางคำพูดของคุณกลับไปยังระบบคลาวด์ของ Amazon
• คำสั่งเสียงจะถูกส่งไปยัง "ทักษะ" ของ Alexa (โปรแกรมที่ทำงานในระบบคลาวด์ของ Amazon)

"ทักษะ" ของ Alexa เข้ามาแทนที่การจัดการคำสั่ง โดยปกติแล้วจะส่งผลให้มีการส่งคำตอบกลับไปยังอุปกรณ์ Alexa ทำให้มีการตอบกลับไปยังผู้ใช้ ในกรณีของ Alexa IoT คำสั่งดังกล่าวจะถูกส่งไปยัง "เงาของอุปกรณ์" บนคลาวด์ของ Amazon ซึ่งท้ายที่สุดแล้วจะส่งผลให้มีการตอบกลับไปยังอุปกรณ์อื่นในบ้านของคุณ เรากำลังข้ามทุกสิ่งด้วยแฮ็คของเรา เราต้องการให้อุปกรณ์ Alexa สื่อสารกับชิป ESP8266 ในบ้านของเราโดยตรง โดยไม่ต้องส่งข้อมูลไปยังคลาวด์และย้อนกลับ เราต้องการให้ Alexa ส่งคำขอโดยตรงไปยัง ESP8266 ของเราทั้งภายในและภายนอกเครือข่าย wifi ที่บ้านเท่านั้น

แฮ็คของเราไม่ใช่ความลับจริงๆ เรากำลังจะทำให้ ESP8266 ของเรา "จำลอง" Wemo Belkin ซึ่งเป็นอุปกรณ์ที่มีใบอนุญาตพิเศษกับ Amazon ทำให้สามารถสื่อสารโดยตรงกับอุปกรณ์ Alexa โดยข้ามการสื่อสารบนระบบคลาวด์ของ Amazon ทั้งหมดที่อธิบายไว้ข้างต้น

โดยอ้างว่าเป็น Wemo ESP8266 ของเรามีสิทธิพิเศษในการรับคำสั่งจาก Alexa ได้โดยตรง

แผนพื้นฐานสำหรับบทช่วยสอน Arduino ESP8266 ของเรา

• ฟัง ESP8266 สำหรับอุปกรณ์ Alexa ที่ส่งโพรบบนเครือข่าย wifi ในพื้นที่สำหรับอุปกรณ์ที่เข้ากันได้ และตอบสนองต่อโพรบเหล่านี้โดยพูดว่า "I'm a Wemo"
• เมื่อได้รับความไว้วางใจจากอุปกรณ์ Alexa แล้ว ให้ฟังคำสั่งเพิ่มเติมจากอุปกรณ์ดังกล่าว จัดการกับพวกมันโดยส่งรหัส IR ผ่านตัวส่ง IR เปิด/ปิดทีวีของเรา

ข้อกำหนดฮาร์ดแวร์

เพื่อให้บทช่วยสอนนี้สมบูรณ์ คุณจะต้องได้รับไอเท็มบางอย่างด้วยตัวเอง ซึ่งทั้งหมดนี้หาได้ง่าย

• อุปกรณ์ Alexa ใด ๆ ฉันได้พัฒนาบทช่วยสอนนี้ด้วย Alexa Dot บทช่วยสอนจะทำงานร่วมกับโปรแกรมจำลองเสียงสะท้อนได้หรือไม่ มันอาจจะ! (แต่ฉันไม่ได้ทดสอบมัน) ลองใช้ดูหากคุณรู้สึกอยากผจญภัย (หรือประหยัด) อุปกรณ์ Alexa เสียเงิน แต่การใช้ Echosim นั้นฟรี
• ชิป ESP8266 พวกเขาเสียค่าใช้จ่ายเพียงไม่กี่ USD ในขณะที่เขียนนี้ คุณสามารถหาซื้อได้จาก Ebay หรือร้านฮาร์ดแวร์ที่มีสต็อกออนไลน์มากมาย
• ไดโอด IR (อินฟราเรด) คุณจะต้องเชื่อมต่อสิ่งนี้กับชิป ESP8266 ของคุณและคุณต้องทำเอง สำหรับโครงการนี้ เราต้องการเพียงความสามารถในการส่ง เราไม่สนใจเกี่ยวกับการรับ IR อย่าลืมต่อสายไดโอดกับ GND และเอาต์พุต 0 เพื่อให้บทช่วยสอนนี้ใช้งานได้ (ถ้าคุณทำอย่างอื่นก็ไม่เป็นไร แต่คุณจะต้องรับผิดชอบในการแก้ไขโค้ดสอนตามนั้น ลิงค์นี้อาจช่วยคุณได้ โปรดทราบว่าเนื่องจากรูปแบบการนับที่ใช้กับ ESP8266 พิน 0 อาจมีป้ายกำกับว่า “D3”
• อะแดปเตอร์อนุกรมที่ด้านหนึ่งเป็น USB (สำหรับเสียบเข้ากับคอมพิวเตอร์ dev ของคุณ) และอีกด้านจะพอดีกับชิป ESP8266
• เครือข่าย wifi ในพื้นที่ที่คุณทราบชื่อผู้ใช้และรหัสผ่าน

เครื่องมือซอฟต์แวร์ Arduino

• Arduino IDE มีเวอร์ชันสำหรับระบบปฏิบัติการหลักทั้งหมด รวมทั้ง Windows บทช่วยสอนนี้ได้รับการพัฒนาบนเวอร์ชัน Ubuntu แต่ฉันได้ติดตั้งและใช้ Arduino บน Windows ด้วยเช่นกัน ไม่มีปัญหา
• ไลบรารีพัฒนา ESP8266 สำหรับ Arduino
• ไดรเวอร์ โชคดีที่ไดรเวอร์สำหรับอแดปเตอร์ของคุณน่าจะเป็นแบบพลักแอนด์เพลย์ ดังนั้นจึงไม่จำเป็นต้องใช้ไดรเวอร์เพิ่มเติม

กำลังตั้งค่าทุกอย่าง

• ติดตั้ง Arduino IDE
• ติดตั้งไลบรารี ESP8266 โดยใช้ Boards Manager

ในการติดตั้งไลบรารี่ ESP8266 โดยใช้ตัวจัดการบอร์ด:

• ใน Arduino IDE ให้เปิด ไฟล์ -> Preferences
• ป้อน URL นี้ใน “Additional Boards Manager URL”: http://arduino.esp8266.com/stable/package_esp8266com_index.json
• คลิกตกลง

• ไปที่ตัวจัดการบอร์ด ( เครื่องมือ -> บอร์ด: [บอร์ดปัจจุบัน] -> ตัวจัดการบอร์ด )

• ในกล่องข้อความ "ตัวกรอง" ให้พิมพ์ "ESP8266"
• คุณควรได้รับรายการสำหรับ “esp8266” เมื่อคุณเพิ่มผู้จัดการบอร์ดเพิ่มเติมแล้ว เลือกและคลิก "ติดตั้ง"

• รอสักครู่—การดาวน์โหลดทุกอย่างต้องใช้เวลา
• รีสตาร์ท Arduino IDE ของคุณ
• เปิด เครื่องมือ -> บอร์ด: และคราวนี้เลื่อนลงไปที่ "โมดูล ESP8266 ทั่วไป" และเลือก

การเพิ่มห้องสมุดบุคคลที่สาม

Arduino มีหลายวิธีในการเพิ่มไลบรารีภายนอกให้กับโปรเจ็กต์ของคุณ หรือที่เรียกว่า "Sketch" เพื่อให้สิ่งต่าง ๆ เรียบง่ายที่สุด สำหรับบทช่วยสอนนี้ เราจะอธิบายอย่างเร็วที่สุด ซึ่งก็คือการคัดลอกโฟลเดอร์เท่านั้น เราจะต้องเพิ่มไลบรารีภายนอกสองไลบรารีเท่านั้นเพื่อให้บทช่วยสอนใช้งานได้: IRemoteESP8266 และ https://github.com/me-no-dev/ESPAsyncTCP

• ในโค้ดบทช่วยสอนใน GitHub ให้ค้นหาไดเร็กทอรี "libraries"
• ในไดเร็กทอรีการติดตั้ง root สำหรับ Arduino (เช่น C:\Program Files\Arduino) ให้ค้นหาไดเร็กทอรีย่อย "libraries"
• คัดลอกไดเร็กทอรี IRemoteESP8266 จากไดเร็กทอรี "libraries" ของบทช่วยสอนลงในไดเร็กทอรี "libraries" ของ Arduino
• คัดลอกไดเร็กทอรี ESPAsyncTCP จากไดเร็กทอรี "libraries" ของบทช่วยสอนลงในไดเร็กทอรี "libraries" ของ Arduino
• รีสตาร์ท Arduino IDE

ตอนนี้ไลบรารีสำหรับการส่ง IR และ async TCP รวมอยู่ในโปรเจ็กต์แล้ว

การตั้งค่า

รูปภาพด้านล่างแสดงการตั้งค่าทั่วไป ซึ่งใช้ได้กับฉันและฮาร์ดแวร์ของฉัน แต่อาจแตกต่างกันไปสำหรับผู้ใช้แต่ละคน คุณสามารถลองตั้งค่าด้านล่าง แต่มีโอกาสที่คุณอาจต้องปรับตามชิปและอะแดปเตอร์เฉพาะของคุณ ตัวอย่างเช่น ของฉันคือ nodemcu ดังนั้นฉันจึงต้องเปลี่ยนวิธีการรีเซ็ตจาก "ck" (ค่าเริ่มต้น) เป็น "nodemcu" นอกจากนี้ ให้ตั้งค่า "พอร์ตดีบัก" เป็น "ซีเรียล" เพื่อให้คุณสามารถใช้ดีบักเกอร์แบบอนุกรมได้ ของฉันคือการตั้งค่าทั่วไป ดังนั้นคุณสามารถใช้การตั้งค่าของฉันเป็นฐานได้ ฉันแค่บอกว่าอย่าแปลกใจถ้าคุณต้องยุ่งกับพวกเขาเพื่อให้กระบวนการคอมไพล์และแฟลชทำงาน

พิสูจน์การตั้งค่าของคุณด้วย ESP8266 Hello World

โครงการ Arduino เริ่มต้นด้วยไฟล์ .ino ไฟล์ .ino กำหนดจุดเข้าใช้งานสองจุด: การตั้งค่าและวนรอบ สำหรับ "สวัสดีชาวโลก" เราจะเปิดไฟเล็กน้อยบน ESP8266 เพื่อตรวจสอบว่าโค้ดของเราใช้งานได้

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

รวบรวมและแฟลชรหัส

ขั้นตอนง่ายๆ ในการคอมไพล์และแฟลช หากการตั้งค่าของคุณถูกต้อง หากต้องการคอมไพล์โดยไม่กะพริบ ให้ไปที่ Sketch -> Verify/Compile จากเมนู Arduino

หากต้องการแฟลชโค้ดไปที่ชิปและคอมไพล์ ให้เลือก Sketch -> Upload จากเมนู Arduino

หากแฟลชสำเร็จ คุณจะเห็นการแสดงความคืบหน้าจาก 0% เป็น 100% ในระหว่างนั้น LED บนชิปของคุณมักจะกะพริบหรือกะพริบ

วิธีทดสอบว่าการดีบักแบบอนุกรมนั้นใช้งานได้:

• อันดับแรก ตรวจสอบให้แน่ใจว่าได้ตั้งค่าพอร์ตดีบักเป็น Serial ( Tools -> Debug port )
• หลังจากที่โค้ดของคุณกระพริบไปที่ชิปเสร็จแล้ว ให้เลือก Tools -> Serial Monitor

เอาต์พุตของดีบักเกอร์แบบอนุกรมหลังจากเริ่มต้นสำเร็จ:

เยี่ยมมาก ใช้งานได้จริง ต่อไป เราต้องการตรวจสอบเอาต์พุต IR ของเรา มาส่งสัญญาณผ่านตัวส่งสัญญาณ IR ของเราและตรวจสอบว่าสัญญาณผ่านเข้ามาหรือไม่

เราจะใช้ประโยชน์จากไลบรารี Arduino IR ที่มีอยู่เพื่อช่วยเรา สิ่งที่ยอดเยี่ยมอย่างหนึ่งเกี่ยวกับ Arduino คือความง่ายในการสแน็ปไลบรารีและโมดูลเข้าและออก สดชื่นมากสำหรับเฟรมเวิร์ก C ++!

เพียงทำตามคำแนะนำในไฟล์ README ของ Git repo เพื่อติดตั้งใน Arduino

รหัสนี้จะกะพริบเครื่องส่งสัญญาณ IR ซ้ำ ๆ IR ไม่สามารถมองเห็นได้ด้วยตามนุษย์ แต่มีคำแนะนำสำหรับการทดสอบ เรียกใช้รหัสนี้ ตรวจสอบ (ผ่านตัวดีบั๊ก) ว่ามันทำงานบนชิปของคุณ จากนั้นเปิดกล้องของอุปกรณ์มือถือของคุณ มองตรงไปที่หลอดไดโอด IR ผ่านกล้องของคุณ หากใช้งานได้ คุณจะเห็นว่าหลอดไฟเปิดและปิดขึ้นอย่างเห็นได้ชัด คุณสามารถลองใช้รีโมตคอนโทรลที่ใช้งานได้ (เช่น รีโมตทีวีมาตรฐาน) รหัสต่อไปนี้จะทำให้หลอด IR เริ่มกะพริบทุกๆ 0.5 วินาที จริงๆ แล้ว มันส่งคำสั่งเปิด/ปิดของ LG ดังนั้นมันอาจปิดและเปิดทีวี LG ของคุณจริง ๆ หากอยู่ใกล้ๆ

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

เริ่มบทช่วยสอน ESP8266

หากทุกอย่างทำงานได้ดี ฉันคิดว่าเราพอใจที่อุปกรณ์พื้นฐานและการตั้งค่าใช้งานได้ และเราพร้อมที่จะเริ่มเนื้อหาในบทช่วยสอน

เชื่อมต่อกับ Wifi

ขั้นแรก เราต้องเชื่อมต่อกับ wifi ในพื้นที่ รหัสด้านล่างจะพยายามเชื่อมต่อกับ Wifi และรายงานความสำเร็จในการเชื่อมต่อ (ผ่านโปรแกรมแก้ไขข้อบกพร่องแบบอนุกรม) ในตัวอย่างโค้ด อย่าลืมแทนที่ค่าของ myWifiSsid ด้วยชื่อผู้ใช้ของเครือข่าย wifi ของคุณ และแทนที่ค่าของ myWifiPassword ด้วยรหัสผ่านที่ถูกต้อง

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

เรียกใช้ Wemo Server

เชื่อมต่อ? ดี. ตอนนี้เรากำลังเข้าสู่เนื้อของโปรเจ็กต์: เซิร์ฟเวอร์ Wemo

Wemo Emulator ของฉันเองจะรวมอยู่ในไฟล์ต้นฉบับสำหรับบทช่วยสอนนี้ ตอนนี้ คุณสามารถค้นหา Google และค้นหาโปรแกรมจำลอง Wemo ที่ง่ายกว่า คุณสามารถหาโค้ดที่เขียนโดยใช้โค้ดน้อยกว่าและเข้าใจง่าย ไม่ว่าอย่างไรก็ตาม อย่าลังเลที่จะตรวจสอบ ทดลอง เขียนของคุณเอง ฯลฯ นั่นคือทั้งหมดส่วนหนึ่งของการทำบทช่วยสอนนี้เป็นของคุณเอง

เหตุผลเบื้องหลังของฉันคือมันใช้ ESPAsyncTCP ทำไมถึงดีแบบนี้? มีเซิร์ฟเวอร์ (หรืออุปกรณ์) จำนวนมากเท่านั้นที่คุณสามารถเรียกใช้บน ESP8266 โดยใช้วิธีนี้ก่อนที่จะเริ่มไม่น่าเชื่อถือ ในแง่ที่ว่า Alexa จะเริ่มอุปกรณ์ที่หายไป (หาไม่พบ) คำสั่งจะลดลงและประสิทธิภาพ กลายเป็นช้า ฉันพบว่าจำนวนนี้ถูกขยายให้ใหญ่สุดโดยใช้ไลบรารี ESPAsyncTCP

หากไม่มีสิ่งนี้ ฉันพบว่าไม่น่าเชื่อถือที่จะคืบคลานเข้ามาในอุปกรณ์ประมาณ 10-12 เครื่อง ฉันพบว่าตัวเลขนั้นสูงถึงประมาณ 16 ในกรณีที่คุณต้องการขยายบทช่วยสอนนี้และสำรวจขีดจำกัดของสิ่งที่ชิปสามารถทำได้ ฉันขอแนะนำให้ใช้เวอร์ชันของฉัน หากคุณต้องการดูเวอร์ชันที่ง่ายกว่าเพียงเพื่อความเข้าใจของคุณเอง อย่าลังเลที่จะค้นหา "wemo emulator Arduino" บน Google; คุณควรหาตัวอย่างมากมาย

ตอนนี้ เราต้องติดตั้งไลบรารี่ ESPAsyncTCP ติดตั้งเหมือนกับที่เราทำกับไลบรารี IR; ไปที่หน้า Git และทำตามคำแนะนำ

ไลบรารีนี้รวมอยู่ในโค้ดตัวอย่าง esp8266 arduino ของฉันด้วย นี่เป็นเพียงรหัสในการเปิดการเชื่อมต่อ wifi ฟังคำขอการค้นพบของ Alexa และจัดการโดยส่งคืนการตอบกลับ "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(); } }

ก่อนการทดสอบ

ทดสอบสิ่งที่เรามี (wifi และอีมูเลเตอร์) โดยเรียกใช้กับ Alexa บทช่วยสอนนี้อนุมานว่าอุปกรณ์ Alexa ของคุณได้รับการตั้งค่าและติดตั้งในบ้านของคุณ

ทดสอบการค้นพบ:

พูดกับ Alexa ว่า "Alexa ค้นพบอุปกรณ์"

ซึ่งจะทำให้ Alexa เผยแพร่คำขอ UDP บนเครือข่าย wifi ในพื้นที่ของคุณ สแกนหา Wemos และอุปกรณ์อื่นๆ ที่เข้ากันได้ คำขอนี้ควรได้รับในการเรียก wemulator->listen(); ในฟังก์ชันลูป () ซึ่งจะเปลี่ยนเส้นทางไปยังเมธอด handleUDPPacket(*) ของ Wemulator การตอบสนองจะถูกส่งออกไปใน nextUDPResponse() สังเกตเนื้อหาของคำตอบนั้น:

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

นี่คือรหัสที่บอก Alexa ว่า "ฉันเป็น Wemo (Belkin) ฉันจะช่วยคุณได้อย่างไร" เมื่อ Alexa ได้รับการตอบกลับ ก็จะรู้และจำได้ว่าคำสั่งบ้านอัจฉริยะในอนาคตอาจถูกส่งไปยังอุปกรณ์นี้

เอาต์พุตของดีบักเกอร์แบบอนุกรม ณ จุดนี้ควรมีลักษณะเหมือนภาพด้านล่าง เมื่อค้นพบเสร็จแล้ว Alexa จะบอกคุณด้วยวาจาว่ามี "อุปกรณ์ที่ค้นพบ [N]" ในเครือข่ายของคุณ

ในฟังก์ชัน setup() ให้สังเกตข้อมูลโค้ดต่อไปนี้:

 new WemoCallbackHandler(&commandReceived)

นี่คือการโทรกลับที่เราจะรวบรวมคำสั่งจาก Alexa เนื้อหาของมันถูกกำหนดใน WemoCallbackHandler.h (WemoCallbackHandler::handleCallback) เมื่อเรารับคำสั่งจาก Alexa แล้ว เราก็สามารถทำสิ่งที่ชอบได้ ในบรรทัดก่อนหน้านั้น เราได้ตั้งค่าคำสั่งที่เป็นไปได้ที่สามารถใช้ได้ ด้วยบรรทัดของโค้ดเหล่านี้:

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

ดังนั้นนี่คือ "เซิร์ฟเวอร์" หรือผู้ฟัง 4 ตัวที่เรากำลังเรียกใช้บนชิป สิ่งนี้ตั้งค่าความสามารถในการพูดคำสั่งใด ๆ ต่อไปนี้กับ Alexa:

Alexa, เปิดทีวี Alexa, ปิดทีวี Alexa, เปิดโทรทัศน์ Alexa, ปิดโทรทัศน์ Alexa, เปิดทีวีของฉัน Alexa, ปิดทีวี Alexa ของฉัน, เปิดโทรทัศน์ Alexa, ปิดโทรทัศน์ของฉัน

และนี่คือวิธีที่เราจะทดสอบ เราคาดหวังว่าการกล่าวคำสั่งใดๆ เหล่านี้ควรปลุกโค้ดของเราและป้อนการโทรกลับนั้น ซึ่งเราสามารถทำสิ่งที่ชอบได้

เพิ่มคำสั่ง IR

เมื่อเราได้รับคำสั่งแล้ว ก็ถึงเวลาจัดการโดย... เปิด/ปิดทีวีของเรา นี่จะเป็นทุกอย่าง—wifi, wemo emulator และ IR— ทั้งหมดรวมกัน ทีวีของฉันคือ LG ดังนั้นฉันจึงค้นหาลำดับที่เหมาะสมสำหรับการเปิด/ปิด และส่งผ่านฟังก์ชัน sendNEC ของไลบรารี IR ของเรา (LG ใช้โปรโตคอล NEC) การเข้ารหัส/ถอดรหัส IR เป็นเรื่องแยกต่างหากในตัวเอง โดยที่ข้อความจะถูกเข้ารหัสในการมอดูเลตสัญญาณ เป็นข้อกำหนดของการกำหนดเวลา เครื่องหมาย และช่องว่างที่แม่นยำมาก ผู้ผลิตแต่ละรายมีแนวโน้มที่จะใช้โปรโตคอลที่เป็นกรรมสิทธิ์ของตนเองสำหรับคำสั่งและกำหนดเวลาต่างกัน มันค่อนข้างน่าสนใจ และคุณสามารถเจาะลึกลงไปได้โดยการดูซอร์สโค้ดของไลบรารี IR นั้น googling ฯลฯ แต่เพื่อความสะดวกของเรา รายละเอียดของทั้งหมดที่เราดูแลโดยไลบรารี IR ของเรา

ทีวีของคุณไม่ใช่ LG? เพียง google รหัสที่ถูกต้อง นี่คือคำสั่งสำหรับทีวี Sony (คำเตือน: ไม่ได้ทดสอบ):

 irSend.sendSony(0xa90, 12);

หากคุณต้องการลงมือทำด้วยตัวเองจริงๆ คุณสามารถตั้งค่าตัวรับ IR เล็งรีโมทของคุณ (หรือตัวส่งสัญญาณ IR ใดๆ ก็ตาม) ไปที่มัน และถอดรหัสรหัสที่มันส่ง นั่นเป็นบทช่วยสอนที่แตกต่างกัน

สิ้นสุดการทดสอบ

• วาง Alexa ของคุณไว้ที่ใดก็ได้ที่สามารถได้ยินคุณ
• วาง ESP8266 ของคุณด้วยไดโอด IR ที่แนบมา ภายในช่วงการควบคุมระยะไกลของทีวี
• พูดว่า "Alexa ค้นพบอุปกรณ์" รอให้รายงานความสำเร็จ (ควรพบอุปกรณ์อย่างน้อยหนึ่งเครื่อง)
• พูดว่า "Alexa เปิดทีวีของฉัน" หรือ "Alexa ปิดทีวีของฉัน"

Alexa ควรเข้าใจคำสั่งของคุณ (ในฐานะคำสั่งบ้านอัจฉริยะ ไม่ใช่สำหรับทักษะเฉพาะ) ค้นหาอุปกรณ์ในพื้นที่เพื่อจัดการ และส่งคำสั่งไปยังอุปกรณ์ (ESP8266 ของคุณ) อุปกรณ์ของคุณควรรับและส่งคำสั่งการควบคุมระยะไกลไปยังทีวี คุณสามารถดูไดโอดของคุณผ่านกล้องโทรศัพท์มือถือเพื่อให้แน่ใจว่าไดโอดเปล่งแสง

เนื่องจากรหัส IR ในการปิดทีวีนั้นเหมือนกับรหัสในการเปิดทีวี ไม่สำคัญว่าคุณจะให้คำสั่งเปิด “เปิด” หรือ “ปิด” เป็นรหัสเดียวกันและสลับสถานะ หากทีวีปิดอยู่ ก็ควรเปิด และหากเปิดอยู่ก็ควรปิด

การแก้ไขปัญหา

คุณเชื่อมต่อกับ Wifi หรือไม่?

คุณป้อนชื่อผู้ใช้/รหัสผ่านที่ถูกต้องลงในค่าตัวแปรที่ถูกต้องหรือไม่?

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

คุณได้รับข้อความแสดงข้อผิดพลาดหรือข้อผิดพลาดใดๆ ผ่านพอร์ตแก้ไขข้อบกพร่องแบบอนุกรมเมื่อเชื่อมต่อกับ Wifi หรือไม่

Wifi ของคุณเปิดอยู่หรือไม่ และคุณสามารถเชื่อมต่อผ่านวิธีการอื่นทั่วไปได้หรือไม่

อุปกรณ์ของคุณถูกค้นพบโดย Alexa หรือไม่?

Alexa จะส่งคำขอเพื่อค้นหาอุปกรณ์เมื่อคุณพูดว่า "Alexa ค้นหาอุปกรณ์"

Alexa ของคุณต้องได้รับการกำหนดค่าและตั้งค่าอย่างถูกต้อง และเชื่อมต่อกับเครือข่าย Wifi เดียวกันกับ ESP8266 ของคุณ

ดูใน Fauxmo.h ดูฟังก์ชัน Fauxmo::handle() นี่เป็นรหัสแรกที่จะทำงานเมื่อ ESP8266 ได้ยินการโทร ใส่ในข้อความแก้ไขข้อบกพร่องเพื่อดูว่ามีรหัสใดหลังจาก

 if (len > 0) {

กำลังวิ่ง. ถ้าไม่ใช่ แสดงว่าไม่ได้รับคำสั่ง หากใช่ แสดงว่ากำลังได้รับคำสั่ง แต่ไม่ได้รับการจัดการอย่างถูกต้อง ทำตามรหัสจากที่นั่นเพื่อค้นหาว่าปัญหาคืออะไร

คุณมีอุปกรณ์อื่นๆ ที่สามารถค้นพบได้ในเครือข่ายของคุณหรือไม่? มากเกินไปอาจทำให้การค้นพบทำงานช้าลง หรือแม้กระทั่งบางครั้งอาจล้มเหลว

อุปกรณ์ของคุณได้รับคำสั่งหรือไม่?

เมื่อคุณออกคำสั่ง "Alexa เปิดทีวีของฉัน" การดำเนินการควรเข้าสู่ WemoCallbackHandler::handleCallback handler ของคุณ (ในไฟล์ WemoCallbackHandler.h) หากคุณยังไม่ได้ดำเนินการดังกล่าว ให้ลองแสดงข้อความการดีบักในนั้นเพื่อให้แน่ใจว่าข้อความเริ่มทำงานเมื่อคุณออกคำสั่ง นอกจากนี้ ให้ลองตรวจสอบให้แน่ใจว่า Alexa รู้เกี่ยวกับอุปกรณ์ของคุณโดยพูดว่า "Alexa ค้นหาอุปกรณ์" ก่อนออกคำสั่งของคุณ ขั้นตอนนี้ถือว่าการค้นพบอุปกรณ์สำเร็จแล้ว

IR ไดโอดเปล่งแสงหรือไม่?

ตามที่อธิบายไว้ก่อนหน้านี้ เมื่อคุณคิดว่าอุปกรณ์ของคุณควรจะปล่อยสัญญาณ ให้เล็งกล้องของโทรศัพท์มือถือไปที่อุปกรณ์แล้วมองที่ไดโอดผ่านกล้อง แม้ว่าในชีวิตจริงคุณจะมองไม่เห็นสิ่งใด แต่ควรปรากฏผ่านกล้องเป็นแสงปกติที่ส่องและกะพริบ ถ้าคุณเห็นสิ่งนี้ แสดงว่ามันเปล่ง... อะไรบางอย่าง

สัญญาณ IR กลับด้านหรือไม่?

ไดโอด IR ของคุณอาจต่อสายในลักษณะที่สัญญาณกลับด้าน โปรดอดทนกับคำอธิบายของฉันเพราะฉันไม่ใช่คนอิเล็กทรอนิกส์หรือช่างเดินสาย แต่ผลของการเดินสายไดโอดผิดจะทำให้ไฟ IR ติดสว่างตามค่าเริ่มต้น แต่ปิดเมื่อห้องสมุด IRSend ตั้งใจที่จะเปิด มันบน หากเป็นกรณีนี้ ไฟ IR ของคุณควรเปิดอยู่ (มองเห็นได้ผ่านกล้อง) โดยค่าเริ่มต้น หลังจากที่โค้ด setup() ทำงาน แต่ก่อนสิ่งอื่นใดจะเกิดขึ้น หากคุณต้องใส่ความคิดเห็นออกโค้ดทั้งหมดใน loop() คุณควรเห็นว่าโค้ดนั้นเปิดอยู่อย่างต่อเนื่อง

หากต้องการทราบวิธีแก้ไขปัญหานี้ให้ชัดเจนยิ่งขึ้น ให้ไปที่โฟลเดอร์ libraries/IRemoteESP8266/src ของโค้ดบทช่วยสอน ดูตัวสร้าง:

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

อาร์กิวเมนต์ "กลับด้าน" และตรรกะที่จัดการกับมันคือสิ่งที่เรากำลังพูดถึง หากการเดินสายของคุณกลับด้าน วิธีแก้ปัญหาที่ง่ายที่สุดคือทำการเปลี่ยนแปลงเล็กน้อยในโค้ดเพื่อให้สามารถดำเนินการได้ (แทนที่จะเดินสายใหม่… แต่ถ้าแน่นอน คุณสามารถทำได้หากต้องการ) เพียงเปลี่ยนบรรทัดนี้ใน AlexaTvRemote.ino:

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

ถึง

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

คุณมีรหัสและคำสั่งการควบคุมระยะไกลที่ถูกต้องหรือไม่?

หากทุกอย่างดูเหมือนจะโอเค แต่ทีวีไม่เชื่อฟัง ก็มีแนวโน้มว่าจะมีบางอย่างผิดปกติกับรหัส IR ลองเรียกใช้ฟังก์ชันอื่นบนอินเทอร์เฟซไลบรารี IR นั้น (เช่น sendLG , sendPanasonic , sendSharp ฯลฯ ) หรือตรวจสอบให้แน่ใจว่าฟังก์ชันที่คุณใช้ตรงกับฮาร์ดแวร์ของคุณ ไลบรารีนั้นไม่น่าจะสนับสนุนฮาร์ดแวร์ของทีวีของคุณ แต่ฉันเดาว่ามันเป็นไปได้ในทางเทคนิค

ตรวจสอบให้แน่ใจว่ารหัสที่คุณส่งเป็นรหัสที่ถูกต้องสำหรับฮาร์ดแวร์ของคุณ คุณอาจต้องทำการขุดค้นบน google เพื่อค้นหาสิ่งที่ถูกต้อง หากสิ่งอื่นล้มเหลว จะมีตัวเลือกในการตรวจหารหัสที่ส่งออกมาจากรีโมทที่ทำงานของคุณเสมอ เมื่อคุณกดปุ่มเปิด/ปิด—แต่นั่นเป็นบทแนะนำที่แตกต่างออกไปและต้องใช้ฮาร์ดแวร์ที่แตกต่างกัน

ห่อ

หวังว่าทุกอย่างจะได้ผลสำหรับคุณ ถ้าเป็นเช่นนั้น (และอาจจะถึงแม้จะไม่ใช่ก็ตาม) นี่เป็นวิธีที่ดีในการตัดฟันของคุณในหลายเรื่องพร้อมกัน:

• Alexa
• โปรแกรมสมองกลฝังตัว
• ชิป ESP8266
• Arduino IDE

และแน่นอนว่า คุณอาจมีความสะดวกเล็กน้อยในการเปิด/ปิดทีวีด้วยคำสั่งเสียง

ทำไมต้องแฮ็ค?

เหตุใดจึงเป็นการแฮ็ก และไม่ใช่ส่วนหนึ่งของ API พื้นฐานสำหรับ Alexa หลังจากเรียนรู้วิธีพัฒนาทักษะแรกของ Alexa แล้ว สิ่งที่ฉันต้องการทราบก็คือ "ฉันจะส่งคำสั่งโดยตรงจาก Alexa ไปยังอุปกรณ์อื่นบนเครือข่ายได้อย่างไร" น่าเสียดายที่ Amazon ไม่ได้เปิดเผย API เต็มรูปแบบสำหรับการสื่อสารระหว่างอุปกรณ์ Alexa กับอ็อบเจ็กต์อื่นๆ บนเครือข่ายท้องถิ่น โดยไม่ต้องผ่านกระบวนทัศน์ "ทักษะ" หรือ "บ้านอัจฉริยะ" (ซึ่งทุกอย่างต้องส่งไปยัง AWS ก่อนทำสิ่งใด) แต่พวกเขาก็ยังไม่ได้

พยายามต่อไป

ลองใช้ชุดคำสั่งรีโมตคอนโทรลเพื่อควบคุมทีวีของคุณอย่างเต็มที่ยิ่งขึ้น เช่น การเปลี่ยนช่องและควบคุมระดับเสียง ทดสอบขีดจำกัดของชิปโดยดูว่าคุณสามารถฟังคำสั่งต่างๆ ได้กี่คำสั่งใน ESP8266 หนึ่งคำสั่ง (คำใบ้: ตัวเลขนี้แทบจะแตกเป็นตัวเลขสองหลัก โดยไม่ต้องตั้งโปรแกรมที่ฉลาดมาก) หากคุณใช้ฮาร์ดแวร์ได้ดี ให้ลองควบคุมอุปกรณ์อื่นๆ ที่ ไม่ ผ่าน IR โดยการเดินสายไปยังชิป ESP8266 โดยตรง เช่นแสงและอื่น ๆ พลิกโฉม wemo!