ARduino ep2

CH1 เริ่มต้นกับ depaAgBoard

บทที่1 เริ่มต้นกับ depaAg Board แนะนำพื้นฐาน โมดูล ESP32 บน depaAg Board
สวัสดีครับ วันนี้นะครับ ก่อนที่เราจะเข้าสู่เนื้อหา

เรื่อง IOT ก็มาดูในเรื่องของบทที่ 1

ซึ่งจะเป็นในเรื่องของการแนะนำพื้นฐาน

โมดูล ESP32 ครับ ในส่วนของ

ฟีเจอร์หลัก ESP32 นะครับ

มันก็จะเป็นตัว CPU in dual core นะครับ

ความเร็วในการประเมินผล 240 MHz

ด้วยการประเมินผลคำสั้ง

สามารถประเมินผล 600 DMIPS นะครับ

มีขนาด Ram 520 KB

แล้วก็รวมถึงใน

ตัวชิปเองจะมีเรื่องของ WiFi โมดูล

อยู่แล้วนะครับ ไม่ว่าจะเป็นรองรับมาตรฐาน

802.11 b/g/n ครับ

แล้วก็มีในส่วนของ Bluetooth นะครับ

ซึ่งเป็น BLE นะครับ เป็น Bluetooth Low Energy

มี flash memory นะครับ

ขนาด 16 MB นะครับ

แรงดันที่ใช้ในการทำงานจะอยู่ที่

2.3 V ถึง 3.6 V นะครับ

อุณหภูมิในการใช้งานจะอยู่ที่

-40°C to +125°C นะครับ

บนบอร์ดบางโมดูลก็จะมี

เสาอากาศ หรือว่า PCB antenna อยู๋บนบอร์ด

ส่วนบางโมดูลก็จะมี connector

ที่เป็น IPEX นะครับ สำหรับต่อสายอากาศภายนอก

เพื่อขนาดให้สามารถรับส่งสัญญาณ WiFi ได้ไกลขึ้นนะครับ

เมื่อกี้เราพูดถึงในส่วนของฮาร์ดแวร์ไปแล้ว

ที่ลองมาดูในด้านของซอฟต์แวร์

หรือเครื่องมือที่จะเอามาใช้ในการพัฒนา

ตัวชิปโมดูลตัวนี้นะครับ

มีหลายหลากมากมายในปัจจุบันนะครับ

ตัวที่เป็นที่รู้จัก แล้วก็นิยมใช้มากที่สุดนะครับ

ก็จะเป็นแพลตฟอร์ม Arduino IDE นะครับ

หลังจากนั้นช่วงนี้ก็จะมีเริ่มพัฒนามาเรื่อย ๆ

ตั้งแต่ KBIDE นะครับ ตัวของเจ้าของ

บริษัทที่ผลิตชิปตัวนี้เองนะครับ

หรือว่า ESPRESSIF มีเครื่องมือในการพัฒนาตัวชิป

ที่ชื่อว่า ESPRESSIF IDE นะครับ

นอกจากนี้ในชิปก็ยังรองรับ

ภาษาได้หลายหลากนะครับ

รวมถึงตัว MicroPython นะครับ

ด้วยความนิยม และด้วยความสามารถนะครับ

แล้วก็มีราคาถูก ก็จะมีหลายบริษัท

หรือหลายผู้ผลิตนะครับ

ที่นำชิปตัวนี้ไปผลิตเป็นบอร์ดพัฒนา

เพื่อให้ง่ายในการที่นำมาใช้

ในการออกแบบ หรือสร้างสรรค์นวัตกรรมใหม่ ๆ นะครับ

ยกตัวอย่างจะเป็นชิปของฝั่ง

ทางด้านประเทศจีน DOIT ก็ใช้ชื่อว่า

DEVKIT V1 แล้วก็มี NodeMCU นะครับ

หรือ ESP32 Thing นะครับ

อันนี้เป็นตัวอย่าง WeMos ก็จะมีอีกหลาย

รูปแบบที่นำเพื่อให้

ผู้พัฒนาหรือเหล่าเมกเกอร์ทั้งหลาย

เอาบอร์ดตัวนี้ไปใช้ได้อย่างง่ายนะครับ

ส่วนที่จะเน้นการในเนื้อหา

บทเรียนนี้ ก็จะเลือกชิปตัวหนึ่งขึ้นมา

ซึ่งเป็นที่นิยม และราคาไม่แพง ชื่อว่า ESP32 DEVKIT

ก็จะมีอยู่หลายเวอร์ชั่น

ที่นี้ในเรื่องของการที่จะนำชิปตัวนี้

ไปใช้งานนะครับ

ต้องมาทำความเข้าใจก่อนว่าแต่ละขา

เอาไปใช้ทำอะไรได้บ้าง จะป้อนไปตรงไหน

จะเอาไปควบคุม input-output ในขาอะไรบ้างนะครับ

ที่นี้ลองมาดูในส่วนของ block diagram นะครับ

ชิปตัวนี้มีฟีเจอร์

หรือว่าแบ่งการทำงานในส่วนใดบ้างนะครับ

อย่างที่บอกไปตั้งแต่ต้นนะครับว่าตัวนี้เป็น

controller ที่มี CPU ที่เป็น dual core นะครับ

แล้วก็รองรับในเรื่องของการเชื่อมต่อใน

หลากหลายรูปแบบ แกนของฝั่งซ้าย เช่น

SPI, I2C นะครับ

แล้วก็จะมีหลายพอร์ตที่นิยมใช้ใน

อุสาหกรรม แล้วก็เอาไปใช้ในหลาย ๆ ภาคส่วนนะครับ

ในตัวมันเองก็จะโมดูลที่เป็น WiFi โมดูลเองนะครับ

มีส่วนโมดูลที่เป็น Bluetooth นะครับ

แล้วก็ยังมี

วงจร RTC หรือวงจรนาฬิกาอยู่ในตัวชิป

ยังสามารถรองรับ

ขาที่เป็นทั้ง Digital นะครับ

แล้วก็ Analog อยู่ในตัว ซึ่งจะเอาไปประยุกต์ใช้

ใช้งานได้กว้างขวางและก็หลากหลายมากขึ้นนะครับ

เนื่องจากความสามารถของชิปตัวนี้นะครับ

เราก็เลยนำบอร์ด DEV บอร์ดนี้มา

พัฒนาเป็นบอร์ดสำเร็จรูปนะครับ

เพื่อที่จะได้สะดวกในการที่เหล่าเมกเกอร์ทั้งหลาย

ไม่ต้องมานั่งต่อสาย ไม่ต้องมานั่งเชื่อมสายต่าง ๆ

ก็ออกแบบมาเป็นบอร์ด ที่ชื่อว่า depa AG นะครับ

ด้วยที่มีความประสงค์

ที่จะนำบอร์ดนี้เอาไปใช้ในงานภาคเกษตร

ด้วยบอร์ดนี้ก็จะใช้

ตัว ESP32 โมดูลที่เรียกว่า DEVKIT นะครับ

เอามาเสียบอยู่บนบอร์ดนี้ได้เลยนะครับ

หน้าตาของบอร์ดนะครับ

ในแต่ละส่วนมันมีอะไรบ้าง

เริ่มตั้งแต่ส่วนแรกนะครับ ในบอร์ดนี้

สวิตซ์ที่อยู่บนบอร์ดสามสวิตซ์

ที่ใช้ในการควบคุม หรือเขียนโปรแกรมให้ทำตามที่ต้องการได้

นะครับ อย่างเช่น

สามารถสั่งกดสวิตซ์แต่ละตัวเปิดหรือปิด

Reley ได้เลยนะครับ อันนี้ก็เป็นตัวอย่าง

ที่เตรียมใว้ให้บนบอร์ดนะครับ

ถัดไปก็เป็นส่วนของ output ก็คือมี Relay 3 channel นะครับ

ซึ่งเหล่าเมกเมอร์

หรือผู้ที่สนใจนำบอร์ดนี้ไปใช้งานก็สามารถ

เอาไปควบคุมอุปกรณ์แรงสูง

ไม่ว่าจะเป็นไฟ มอเตอร์ วาล์ว อะไรต่าง ๆ

เข้ามาเชื่อมต่อสายสามารถนำไป

ใช้งานได้เลยนะครับ

เนื่องจาก output ที่เป็น Reley แล้ว

ก็ยังมี input ที่เป็น Digital ด่วยนะครับ

ในกรณีที่ต้องการรับค่า

ข้อมูลที่เป็น 0/1 หรือเป็น Sensor ต่าง ๆ

ที่ส่งสัญญาณ Digital มาก็จะมีเตรียม

ไว้ให้อยู๋ 2 channel นะครับ

ที่นี้จะเห็นว่าความพิเศษ

ตัวบอร์ดนี้

มีการออกแบบให้สามารถรองรับ

Sensor ที่เป็น Sensor ที่ใช้ใน

ภาคอุสาหกรรมได้ที่เป็นโปรโตคอลที่เราเรียกว่า

RS-485 นะครับ ด้วยความพิเศษของโปรโตคอล

คือสามารถรองรับระยะทาง

การเชื่อมต่อตัว sensor ไปจนถึงบอร์ด

ไกลถึง 1 กิโลกว่า ๆ นะครับ

เพราะนั้นก็จะมีประโยชน์ในการที่จะไปใช้

ในภาคเกษตร เนื่องจากมีพื้นที่ประมาณกว้าง

สามารถเชื่อมต่อ sensor ในกี่ตัวก็ได้นะครับ

ด้วยระยะทางได้ถึง 1.2 กิโล ตามทฤษฎี

นะครับ

ในส่วนถัดไปนะครับ

ก็จะเป็นตัวชิปที่เราบอกว่าเรา

นำชิปสำเร็จรูป ซึ่งหาชื่อได้ง่าย

มีขายตามท้องตลาดทั่วไป แล้วก็ราคาไม่แพง

จะใช้ชิปที่เรียกว่า ESP32 DEVKIT นะครับ

สามารถนำปลั๊กมาเสียบเข้าบอร์ดนี้ได้เลยนะครับ

ที่นี้นะครับ

จะเห็นว่าเราจะมีด้านล่าง

ของตัวชิปตัวนี้ จะมีตัวโมดูลที่เป็น

SD Card อันนี้ก็จะเป็นประโยชน์ของนักพัฒนา

กรณีที่อยากจะนำข้อมูล

จาก sensor รับเข้ามา แล้วยังไม่ได้

ส่งข้อมูลขึ้นผ่านอินเทอร์เน็ต ก็สามารถนำข้อมูล

มาไรท์เก็บลงเป็น SD Card

หรือทำเป็น Beta Blockers ก็ได้นะครับ

อันนี้ก็จะเป็นประโยชน์ในแง่ที่จะนำข้อมูล

ไปวิเคราะห๋ในอนาคตต่อไป

ทำให้สามารถใช้งานได้สะดวกนะครับ

นอกจากนั้นแล้วนะครับในบอร์ดนี้

ก็จะมีตัวพอร์ตนะครับสำหรับรองรับ

การ Display หรือการแสดงผล

ในส่วนที่เรียกว่า OLED นะครับ

เพื่อให้นักพัฒนานำตัวโมดูล

ที่เป็น OLED มา plugin เข้าไปตรงนี้แล้วเสียบ

เขียนโปรแกรม เพื่อให้มัน Display ค่าต่าง ๆ บนบอร์ดได้เลย

นะครับ

อันนี้ก็เป็นตัวอย่างของโมดูลที่เป็น OLED

ที่เรามาเสียบ

ที่เราลองมาดูภาพรวมกันบ้างนะครับ ก่อนที่เราจะมา

ออกแบบระบบควบคุม

โดยใช้ IOT นะครับ ดูว่าแนวทาง

การออกแบบเป็นอย่างไรครับ

จากภาพที่เห็นนะครับ ก็จะเห็นว่าตัวหลัก หรือหัวใจสำคัญ

ของการควบคุม ก็จะใช้ตัวบอร์ดที่เรียกว่า

ESP32 DEV บอร์ดตัวนี้แหละ

มาใช้ในการเป็นตัวกลาง หรือเป็นหน่วย

ประมวลผลหลักครับ ซึ่งอาศัยข้อมูลจากไหนนะครับ

ก็จาก sensor ต่าง ๆ ทางด้านซ้ายมือ

อันนี้ก็จะเป็นยกตัวอย่างว่า ต้องการเอา sensor

ต้องการวัดค่าแสงนะครับ

อุณหภูมิ ความชื้นในอากาศ

หรือต้องการวัดค่าความชื้นในดิน

ว่ามีค่าเท่าไร จากนั้นข้อมูลจะถูกส่งผ่าน

โปรโตคอล ที่ทางบอร์ดรองรับ RS-485

ที่สามารถมีระยะทางนะครับ

ระหว่างตัว sensor กับบอร์ดได้กิโลกว่าๆ

ที่นี่พอรับข้อมูลมาแล้วนะครับ

หน่วยของตัวบอร์ดตัวนี้ก็จะ

ทำการประมวลผลนะครับ ขึ้นอยู่กับเงื่อนไข

ขึ้นอยู่กับความต้องการของแต่ละ

แอปพลิชัน แต่ละ

ฟังก์ชั่นการใช้งาน ว่าจะเอาข้อมูลเหล่านี้

มาทำอะไร แน่นอนว่าส่วนนึง

เราเอามาเป็นเงื่อนไขในการควบคุม อีกส่วนนึง

เราส่งข้อมูลขึ้นไปบน Cloud

เนื่องจากเราใช้ข้อมูล IOT เชื่อมต่อ

กับอินเทอร์เน็ต เพราะฉะนั้นข้อมูลนอกจาก

นำมาใช้ในเงื่อนไขการตัดสินใจควบคุมแล้ว

ส่งขึ้นเป็น Cloud เพื่อนำข้อมูลไปเก็บนะครับ

ถึงแม้ว่าบอร์ดเองจะมีตัว SD Card

ในการเก็บข้อมูลบนบอร์ดอยู่แล้วนะครับ ก็สามารถ

ส่งขึ้นไป เพื่อนำไปแสดงผลครับ

นำไปเชื่อมต่อ นำไปส่งให้กับ

ส่วนที่เป็น Mobile Application นะครับ ที่ใช้ในการ

ที่จะสามารถสั่งงานนะครับ ผ่านระยะไกล

หรือนำข้อมูลไปแสดง

กับที่ไหนก็ได้ หรือกรณีที่

ต้องการแจ้งเตือน กรณีที่เกิดเหตุ

ผิดปกติ อุณหภูมิร้อนไปนะครับ

หรือมีการปิดเงื่อนไข

หรืออยากรู้ว่า

ปั๊มมีทำงาน หรือไม่ทำงานสามารถ

ส่ง notify เหล่านี้นะครับ แจ้งเตื่อนไปที่

Line notification หรือ Social อื่น ๆ

ก็สามารถทำได้ อันนี้ก็จะเป็นแนวทาง

ในการที่จะนำบอร์ดนี้นะครับ

เอาไปประยุกต์ใช้งานนะครับ

ก่อนที่เราจะมาเข้าสู่เนื้อหา

หรือการใช้งานของบอร์ดตัวนี้นะครับ

ก่อนอื่นก็อยากจะแนะนำในส่วนของพื้นฐาน

อิเล็กทรอนิกส์นะครับ อุปกรณ์ไฟฟ้าต่าง ๆ

ที่จำเป็นที่เราจะเอามาเกี่ยวข้องนะครับ

ในการเชื่อมต่อของบอร์ดนี้นะครับ

ความรู้พื้นฐานในส่วนแรกเลยเป็นความจำเป็น

อย่างมากเลยเวลาที่เราจะนำบอร์ดไปควบคุม

อุปกรณ์อะไรต่าง ๆ เราต้องรู้

ค่าพื้นฐานของหลักไฟฟ้า

ในเรื่องของกฏของโอห์มนะครับ

ซึ่งในกฏของโอห์มก้จะมีอยู่สามค่าหลัก ๆ นะครับ

ก็คือส่วนที่เป็น Voltage หรือแทนด้วย V นะครับ

หรือส่วนที่เป็นกระแส แทนด้วย I

ส่วนที่เป็นความต้านทาน

แทนด้วย R เพราะฉะนั้นค่า

สามารถโดยใช้ความสัมพันธ์

ของสามค่าเหล่านี้ ถ้าดูจาก

สามเหลี่ยมอยากรู้ค่าตัวไหน ก็ปิดตัวนั้นนะครับ

ก็สามารถจะคำนวณได้ ซึ่งประโยชน์ของ

การรู้พื้นฐานตรงนี้นะครับ

จะได้มาเลือกอุปกรณ์หรือว่าคำนวณได้ว่า

ถ้าเราจะต้องการควบคุมมอเตอร์

กินกระแสเท่านี้ เราควรจะใช้แรงดันเท่าไร

หรืออะไรประมาณนี้นะครับ ตัวอย่างอันนี้คือ

เป็นเรื่องความสัมพันธ์ระหว่างแรงดัน กระแส

ก็ความต้านทานนะครับ

ส่วน

ในค่าอื่นนะครับ อย่างเช่น

อีกส่วนนึงในเรื่องความสัมพันธ์

ระหว่างกำลังงานที่เราใช้

===============================================

Workshop เริ่มต้นใช้งานโปรแกรม Arduino

Makerplayground

สวัสดีครับ ในวันนี้ผมจะมาแนะนำให้

ทุกๆ ท่านรู้จักกับตัว Software Maker Playground นะครับ

ซึ่งเป็น Software พัฒนาระบบสองกลฝั่งตัว

หรือว่า IOT แบบครบวงจรนะครับ

นี้ตัว Software นะครับ สามารถ

ดาวน์โหลดได้จาก www.makerplayground.io นะครับ

ก็สามารถดาวน์โหลดจากลิงค์

ทางด้านนี้นะครับ มีทั้ง Windows และก็ Mac นะครับ

เมื่อดาวน์โหลดมาเสร็จแล้วก็

สามารถติดตั้ง อันนี้ผมดาวน์โหลดมาเสร็จ

เรียบร้อยนะครับ ก็จะลองติดตั้ง

ก็

continue นะครับ แล้วก็

ตั้งตามขั้นตอน

เมื่อติดตั้งเสร็จก็สามารถเปิดตัวโปรแกรมนะครับ

ไปกดในตัวไอคอนโปรแกรม Maker Playground นะครับ

จากนั้นก็จะได้ตัวหน้าต่างโปรแกรม

ตัวโปรแกรม Maker Playground จะมีการทำงาน 3 โหมดหลักๆ

ตัวที่ 1 ก็คือตัว Device Explorer หรือว่าโหมด

สำหรับทดลองค้นหาอุปกรณ์ต่างๆ แล้วก็ลอง

ตัว sensor หรืออุปกรณ์ต่างๆ ครับ

โหมดที่ 2 คือตัวเขียน Diagram นะครับ

ในการเขียนโปรแกรมด้วยตัว Maker Playground

เราจะไม่ต้องเขียนโค้ดด้วยตัวเองนะครับแต่ว่าเราจะใช้

Diagram ในการอธิบายสิ่งที่ต้องการ

สมมุติว่าผมต้องการเปิดตัวหลอดไฟนะครับ

ผมสามารถ search ข้อมูลตัว LED นะครับ

เพิ่มเข้าไปในตัว Project จะได้ตัว LED อยู่ที่ด้านบนนะครับ

จากนั้นผมก็จะให้มันเปิดปิดสลับกัน

คือ เปิด 1 วิ ปิด 1 วิ สลับกันไปเรื่อยๆ

ผมก็สามารถสร้าง scene ใหม่นะครับ

แล้วก็เพิ่มตัวหลอดไฟ LED นะครับ

เชื่อมต่อเข้ากับตัว Begin

แล้วก็สร้างอีก scene หนึ่งนะครับ

Copy ขึ้นมาเป็นอีก 1 scene นะครับ

เชื่อมต่อกัน จะเห็นว่าใน scene ที่ 1

ผมจะเลือกให้ LED 1 ON ก็คือ

หลอดไฟเปิด จากนั้น Relay หรือว่ารอ

1 วินะครับ จากนั้น scene ที่ 2 นะครับ

ตอนนี้ LED ผมเปลี่ยนสั่งให้ปิดนะครับ

กดที่ไอคอน LED นะครับ

แล้วเลือก Action เป็น OFF หรือว่าปิด

แล้วก็ตั้ง Relay เป็น 1 วินะครับ อันนี้ก็จะ

เสร็จสิ้นการเขียนโปรแกรมแล้วนะครับ ก็คือเริ่มต้น

ไฟเปิด รอ 1 วิ แล้วก็ไฟปิดสลับกันไป

เรื่อยๆ พอมันจบใน scene ที่ 2 มันก็จะกลับมาเริ่มต้นใหม่

นี้ผมมาในแถบสุดท้าย หรือว่าแถบ Circuit & Sourcecode

นะครับ ในแถบ Circuit & Sourcecode

เราจะสามารถเลือกได้ว่าเราจะใช้บอร์ดรุ่นไหนนะครับ

ตอนนี้ผมใช้ ตัวนี้จะเป็นตัว

Node MCU นะครับของ ESP32

ก็จะเลือกเป็น ESP32 นะครับ เลือก connector

เลือกเป็นตัว DOIT ESP32 DEVKIT

LED ตอนนี้ผมใช้เป็นตัว

LED ที่อยู่บนบอร์ดเลยนะครับ

ก็จะได้ภาพวงจรเป็นแบบนี้เลยนะครับ

แล้วก็ได้ตัว Source code ตรงนี้ตัวโปรแกรม

จะสร้างให้เองอัตโนมัติ ผมก็สามารถกด

Upload นะครับ ก็คือ Upload ลงไปที่ตัวบอร์ดได้เลยนะครับ

เมื่อ Upload เสร็จก็จะเห็นว่า

ตัว LED บนบอร์ดก็จะเปิดปิดนะครับ

สลับกันตามที่เราได้โปรแกรมโดยที่

การเขียนโปรแกรมเราเขียนด้วย Diagram แล้วก็ให้ตัว

Software Maker Playground สร้างโค้ด

แล้วก็แนะนำการต่อวงจรให้นะครับ ในบทต่อๆ ไป

ผมก็จะมาแนะนำการใช้งานสำหรับ

Maker Playground ในรายละเอียดที่

ที่ advanced ขึ้นต่อไปนะครับ ก็ขอบคุณครับ

Workshop Wi-Fi Scan

1.4 นะครับ
ก็ให้ทุกท่นนะครับ เปิดไฟล์ที่ชื่อว่า
WS14_TestWiFiScan นะครับ
จุดประสงค์ของแล็บนี้นะครับ เราต้องการที่จะ
ทำให้เจ้าตัว Module ESP32
ตัวนี้นะครับทำการ scan
หา WiFi ที่อยู่บริเวณใกล้เคียง
ของตัวนี้เองนะครับว่า
มี Access Point รอบๆ ตัว
มีอะไรบ้างนะครับ มีไหนตัว
มีการเข้ารหัสไว้หรือเปล่า หรือตัวไหนที่เป็น Open
เพราะฉะนั้นเราสามารถที่จะ
หลังจากที่เรา Run Code นี้แล้วนะครับ
เาสามารถที่จะเห็นเลยนะครับว่ามี WiFi กี่
Access Point กี่จุด แต่ละจุด
แต่ละตัว
มีรหัส มี channel อะไร มีการเข้ารหัสไว้ไหม
อะไรแบบนี้นะครับ ก็สามารถใช้สเก็ตซ์ตัวนี้นะครับ
ใช้ในการทดสอบหาได้นะครับ งั้นเริ่มต้นนะครับ
จากสเก็ตซืที่เปิดมาในบรรทัดแรก
ก็ต้องมีการ include Library WiFi.h นะครับ
ส่วนคำสั่งหลักๆ ก้จะอยู่
ในส่วนของ
ที่เป็น setup นะครับ ที่เราจะต้องการ
กำหนดการสื่อสารระหว่างบอร์ดกับ
คอมพิวเตอร์นะครับ ว่าใช้อัตราการรับส่งเป็นอย่างไร
แล้วก็ set mode ให้เป็น station mode นะครับ
WIFI_STA นะครับ
จากนั้นนะครับก็
เข้าไปดูใน Loop นะครับ ใน Loop นี่จะเป็น
เป็นการเริ่มต้นให้ตัว
ESP32 ตัวนี้ทำการเริ่ม scan นะครับ
คือเราก็จะใส่คำว่า scan start นะครับ
เพื่อบอกว่าเดี่ยวจะเริ่มทำการ scan โดยคำสั่งที่
ในการ scan
Access Point หรือ Network ที่อยู่รอบๆ ตัวมัน
จะชื่อว่า WiFi.scanNetwork นะครับ จากนั้นก็จะ
มีการให้วน Loop นะครับ ทำ scan ไปเรื่อยๆ นะครับ
โดยเวลาที่เราให้ scan นี้
กำหนดไว้ 5 วินาที เพราะฉะนั้นในทุกๆ 5 วินาที
ก็จะมีการ scan หา Access Point ที่อยู่รอบๆ
เจ้าตัวบอร์ดตัวนี้ เดี่ยวเรามาลอง
ทำดูเลยนะครับ ก็หลังจากที่เปิดตัวนี้นะครับ
เราเปิด Serial Monitor ไว้นะครับ เช็คบอร์ดเลทให้ตรงกัน
เราตั้งไว้นะครับที่ setup 115200 นะครับ
ตรงนี้ก็ต้องเป็น 115200 ด้วยนะครับ
จากนั้นก็กด Upload นะครับ
ตอนนี้เรารอสักครู่หนึ่งนะครับ
ตอนนี้กำลัง compile ครับ
ตอนนี้ก็ compile ผ่านแล้วนะครับ
เราก็มาทำการ Upload โปรแกรมลง
เดี่ยวเราค่อยไปสังเกตุสิ่งที่ด้าน
Serial Monitor ว่าเกิดอะไรขึ้นบ้างนะครับ
เห็นไหมครับ เบื้องต้น
ก็จะมีการ Scan Network ว่าในรอบๆ ตัวมัน
ว่า Access Point อะไรบ้าง ซึ่งจะมีจำนวน
บอกขึ้นมานะครับ พบทั้งหมดนะครับ
ก็ที่ละรอบนะครับ แต่ละรอบหน่วงเวลา 5 วินาทีนะครับ
อย่างรอบแรกเจอ 42 Network นะครับ
สองที่สองเจอ 39
ก็จะอยู่ประมาณนี้นะครับ นี่แล้วแต่ว่าสัญญาณ
ว่า WiFi มี Access Point แต่ละตัวชื่อว่า
อะไร มีการเข้ารหัสไว้หรือเปล่านะครับ
ส่งสัญญาณนะครับ
ด้วย channel ไหน ก็จะบอกข้อมูลตรงนี้หมด
อันนี้ก็จะเป็นการ
ที่ทำให้เราทดสอบได้ว่าเจ้าตัว ESP32 Module นี้นะครับ
สามารถใช้ scan หา
WiFi ที่อยู่รอบๆ ตัวได้
Workshop ทดสอบ STA Mode
ครับเดี่ยวเรามาต่อในแล็บนี้ ให้ทุกท่านเปิดไฟล์
ที่ชื่อว่า WS13_TestSTA_Mode นะครับ
ในแล็บนี้นะครับ จะเป้นการทดสอบการทำงาน
ในMode STA หรือ
Station Mode นะครับ โหมดนี้นะครับ
ก็จะเป็นการให้ตัว
บอร์ด IDE ESP32 ของเรานะครับ
ไปเกาะตัวอุปกรณ์ที่ปล่อย
สัญญาณ Wi-Fi ออกมา อย่างเช่น router หรืออะไรก็ตาม
เพื่อที่จะให้อุปกรณ์ของเราเชื่อมต่อ
อินเทอร์เน็ตได้ หลังจากที่
ทุกท่านเปิดมาแล้ว ในส่วนของการทำงาน
ของโปรแกรมตัวนี้ เริ่มต้นจาก
การ Input WiFi หรือ Library WiFi เข้ามานะครับ
จากนั้นเราก็จะมีการตั้งชื่อ
ตัว WIFI_STA_NAME นะครับ
ตัวนี้จะเป็นการที่เราจะ
บอกถึงชื่อของ Router อุปกรณ์ที่เราจะให้
ออก WiFi ก็ใส่ชื่อลงไปนะครับ
ซึ่งอันนี้แล้วแต่นะครับว่าของท่านใช้
WiFi ชื่อไร ก็ใส่ชื่อตรงนั้นไปนะครับ
WIFI_STA_PASS ก็คือตัว
รหัสผ่านของ Router หรือของตัวอุปกรณ์
อุปกรณ์ที่จะให้ตัวบอร์ดไปเชื่อมต่อ
ว่ามีรหัสผ่านหรือเปล่า ถ้ามีก็
ใส่รหัสผ่านตรงไปนะครับ ส่วน
บรรทัดถัดไปที่บอกว่า LED_BUILTIN 2 นะครับ
เป็นการกำหนดว่าในบอร์ดนี้
เนื่องจากมีหลอดไฟ LED อยู่
เราต้องการใช้ในการทดสอบว่า ถ้าเกิด
มีการเชื่อมต่อได้นะครับ
ให้หลอดไฟตรงนี้ติดค้าง แต่ถ้า
เชื่อมต่อ WiFi ไม่ได้ หลอดไฟที่อยู่บนบอร์ดนะครับ
จะติดกระพริบเป็นการบอกว่ามัน
สามารถเชื่อต่อ WiFi หรือเชื่อมต่อผ่านเครือข่ายอินเทอร์เน็ต
ได้หรือยัง เพราะฉะนั้นฟังก์ชันหลักๆ
คำสั่งหลักๆ จะมาอยู่ในส่วนของ
ฟังก์ชัน Setup ก็คือตั้งแต่กำหนด
ข้อมูลการสื่อสาร เรื่องของการกำหนดขา
pin ก็คือ
LED_BUILTIN 2 ที่เราใส่เลข 2 ก็คือขา
ของชิปมัน เราต้องการใส่ขานี้เป็น
OUTPUT เนื่องจากวงจรภายในของ
บอร์ดนี้ เขาจะต่อขา 2 เข้ากับ LED_BUILTIN
ข้างใน ซึ่งในบอร์ดนี้เขาใช้สีฟ้านะครับ
เดี่ยวเราจะสังเกตุเห็นว่าถ้ามีการ
ล็อกอินระหว่างการเชื่อมต่อตัว WiFi นี้นะครับ
ตัวหลอดไฟสีฟ้าจะติดกระพริบนะครับ
ติดกระพริบตามไหน ก็ตามโค้ดข้างล่าง
ตั้งแต่บรรทัดที่ 19 ถึง 23 นะครับ ตัวนี้นะครับ
เป็นบรรทัดของการที่สั่งให้หลอดไฟติดกระพริบนะครับ
ในขณะที่กำลังพยายามเชื่อมต่อ
Router อยู่ เพื่อที่จะเกาะเพื่อออก
อินเทอร์เน็ตนะครับ แต่ถ้าเชื่อมต่อสำเร็จแล้วนะครับ
ตัวหลอดไฟสีไฟจะติดค้าง แล้วก็
พร้อมทั้งบอกแจ้งว่าทาง Serial Monitor ว่า
เชื่อมต่อ WiFi สำเร็จแล้ว แล้วก็ได้
IP อะไร จาก Router ที่จ่ายออกมา
ส่วนในฟังก์ชันของ Loop ก็ไม่ต้องเขียนอะไรนะครับ
เดี่ยวเราเปิด Serial Monitor
ค้างไว้แล้วก็กดปุ่ม Upload นะครับ
ตอนนี้ก็รอ ระหว่างนี้นะครับ
โปรแกรมกำลังทำการ compile อยู่
เดี่ยวเรา compile เสร็จเราจะมาดูว่า
หลอดไฟสีฟ้าที่อยู่บน
ตรงนี้นะครับต้องติดกระพริบ
ระหว่างที่กำลังเชื่อมต่อ
ตอนนี้จะเป็นการ Upload เรียบร้อยแล้วนะครับ
เดี่ยวรอข้อมูลที่ออกมาทาง Serial Monitor
ฝั่งนี้เห็นไหมครับ
เมื่อกี้มีกระพริบนิดเดียวนะครับ เนื่องจากว่า
การเชื่อมต่อเร็วมากนะครับ ก็คือแค่
ไม่กี่วินาทีก็เชื่อมต่อได้แล้ว เพราะนั้นสังเกตุว่า
หลอดไฟสีฟ้าติดค้าง แสดงว่าเชื่อมต่อ
กับ Router หรือเชื่อมต่อ WiFi สำเรํจแล้วก็จะมี
ข้อความบอกว่า WiFi connected ด้วย IP
อะไรนะครับ ตอนนี้เชื่อมต่อด้วย IP
192.168.0.55 นะครับ
อันนี้ก็จะเป็นการทดสอบ
ในโหมดของ Setup Mode
นะครับ
Coding for Workshop
uint64_t chipid;
void setup() {
Serial.begin(115200);
}
void loop() {
chipid=ESP.getEfuseMac();//The chip ID is essentially its MAC address(length: 6 bytes).
Serial.printf("ESP32 Chip ID = %04X",(uint16_t)(chipid>>32));//print High 2 bytes
Serial.printf("%08X\n",(uint32_t)chipid);//print Low 4bytes.
delay(3000);
}
#include<WiFi.h>
#define WIFI_AP_NAME "KMM-ESP32"
#define WIFI_AP_PASS NULL
void setup() {
Serial.begin(115200);

WiFi.mode(WIFI_AP);
WiFi.softAP(WIFI_AP_NAME, WIFI_AP_PASS);
Serial.print("SSID: ");
Serial.println(WIFI_AP_NAME);
Serial.print("IP address: ");
Serial.println(WiFi.softAPIP());
}
void loop() { }
#include<WiFi.h>
#define WIFI_STA_NAME "KMM-DEMO-AP"
#define WIFI_STA_PASS "kmm201907"
#define LED_BUILTIN 2 //GPIO2
void setup() {
Serial.begin(115200);
pinMode(LED_BUILTIN, OUTPUT);
Serial.println();
Serial.println();
Serial.print("Connecting to ");
Serial.println(WIFI_STA_NAME);
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_STA_NAME, WIFI_STA_PASS);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
}
digitalWrite(LED_BUILTIN, HIGH);
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
}
void loop() { }
#include "WiFi.h" //เรียกใช้ไลบารี่ WiFi.h
void setup() { //สร้างฟังก์ชั่น setup
Serial.begin(115200); //เริ่มใช้งาน UART0 ที่ความเร็ว 115200
WiFi.mode(WIFI_STA); //เริ่มใช้งาน WiFi ในโหมด STA
WiFi.disconnect(); //หยุดการเชื่อมต่อกับ Access Point ใด ๆ
delay(100); //หน่วงเวลา 100 มิลิวินาที หรือ 0.1 วินาที

Serial.println("Setup done"); //แสดงผลข้อความไปที่ Serial Monitor
} //จบคำสั่งในฟังก์ชั่น setup
void loop() { //สร้างฟังก์ชั่น loop
Serial.println("scan start"); //แสดงผลข้อความไปที่ Serial Monitor
int n = WiFi.scanNetworks(); //เริ่มใช้ฟังก์ชั่น WiFi.scanNetworks() เพื่อสแกนหา WiFi ในพื้นที่ จากนั้นนำจำนวน WiFi ที่เจอไปเก็บไว้ในตัวแปร n
Serial.println("scan done"); //แสดงผลข้อความไปที่ Serial Monitor
if (n == 0) { //ตรวจสอบผลการสแกน หากตัวแปร n เป็น 0 ให้ทำคำสั่งในปีกกา
Serial.println("no networks found"); //แสดงผลข้อความไปที่ Serial Monitor
} else { //หากเงื่อนไขใน if ไม่เป็นจริง ให้ทำคำสั่งในปีกกา
Serial.print(n); //นำค่าในตัวแปร n ไปแสดงผลใน Serial Monitor
Serial.println(" networks found"); //แสดงผลข้อความไปที่ Serial
for (int i = 0; i < n; ++i) { //ใช้คำสั่ง for วนรอบตามจำนวนค่าในตัวแปร n
Serial.print(i + 1); //แสดงผลการนำตัวแปร i ไปบวก 1 ไปที่ Serial Monitor
Serial.print(": "); //แสดงผลข้อความไปที่ Serial
Serial.print(WiFi.SSID(i)); //แสดงผลค่าที่ได้จากฟังก์ชั่น WiFi.SSID() ที่กำหนดให้พารามิเตอร์ลำดับเป็นค่าตามตัวแปร i
Serial.print(" ("); //แสดงผลข้อความไปที่ Serial
Serial.print(WiFi.RSSI(i)); //แสดงผลค่าที่ได้จากฟังก์ชั่น WiFi.RSSI() ที่กำหนดให้พารามิเตอร์ลำดับเป็นค่าตามตัวแปร i
Serial.print(")"); //แสดงผลข้อความไปที่ Serial
Serial.print((WiFi.encryptionType(i) == WIFI_AUTH_OPEN)?"NULL":"เข้าระหัสไว้"); //ใช้ Ternary Operators ตรวจสอบค่าที่ได้จากฟังก์ชั่น WiFi.encryptionType() ที่กำหนดให้พารามิเตอร์ลำดับเป็นค่าตามตัวแปร i ว่าเป็น WIFI_AUTH_OPEN หรือไม่ ถ้าใช่ ส่งค่าว่าง ถ้าไม่ ส่ง * ค่าที่ส่งไปแสดงใน Serial Monitor
Serial.print(" Channal ");
Serial.println(WiFi.channel(i));
delay(10); //หน่วงเวลา 10 มิลิวินาที หรือ 0.01 วินาที
} //จบคำสั่งในปีกกาของคำสั่ง if
} //จบคำสั่งในปีกกาของคำสั่ง for
Serial.println(""); //แสดงผลข้อความไปที่ Serial
delay(5000); //หน่วงเวลา 5 วินาที
} //จบคำสั่งในฟังก์ชั่น loop
บทที่ 2 หัวใจหลัก การควบคุมการทำงาน iot
Coding for Workshop
#include <WiFi.h>
#include <BlynkSimpleEsp32.h>
BlynkTimer timer;
// You should get Auth Token in the Blynk App.
// Go to the Project Settings (nut icon).
char auth[] = "7lwzOjSK2A47ZA05LlzFjML55rgE29BP"; //for device ESP32 Test account plewatc@gmail
// Your WiFi credentials.
// Set password to "" for open networks.
char ssid[] = "KMM-DEMO-AP";
char pass[] = "kmm201907";
/*
* ESP32 Internal Temperature Sensor Example
*/

#ifdef __cplusplus
extern "C" {
#endif
uint8_t temprature_sens_read();
#ifdef __cplusplus
}
#endif

uint8_t temprature_sens_read();
float cTemp;
void getChipTemperature() {
Serial.print("Chip Temperature: ");
// Convert raw temperature in F to Celsius degrees
cTemp = (temprature_sens_read() - 32) / 1.8;
Serial.print(cTemp);
// Serial.print((temprature_sens_read() - 32) / 1.8);
Serial.println("°C");
}
void sendBlynk(){
Blynk.virtualWrite(V0,cTemp);
}
void setup()
{
Serial.begin(115200);
Blynk.begin(auth, ssid, pass);

timer.setInterval(3000L, getChipTemperature);
timer.setInterval(5000L, sendBlynk);
}
void loop()
{
Blynk.run();
timer.run();
}
บทที่ 3 วางระบบควบคุมการให้น้ำผ่านแปลงเกษตรอัจฉริยะ