# Introduction
**บอร์ด CorgiDude (คอร์กี้ดู๊ด) คืออะไร**
ถ้าจะให้กล่าวเรื่องบอร์ดนี้ก็ต้องเท้าความกันเกี่ยวกับเรื่อง AI กันก่อน ในช่วงที่ผ่านมาหลาย ๆ ท่านคงอาจจะเคยได้ยินเรื่องราวเกี่ยวกับ AI (Artificial Inteligent) หรือที่แปลเป็นภาษาไทยได้ว่า **“ปัญญาดิษฐ์”** มีข่าวมากมายเกี่ยวกับการนำไปใช้ในเรื่องต่าง ๆ เช่น แข่งหมาล้อมชนะแชมป์โลกได้ สร้างหน้าผู้ชายเป็นผู้หญิง/ผู้หญิงเป็นผู้ชาย หรือจะนำมาแทนคนบ้างหล่ะ skynet จะยึดครองโลกบ้างหล่ะ ก็ว่ากันไป เรื่องเหล่านี้สะท้อนได้ว่าแต่ละคนมีทัศนคติเกี่ยวกับ AI แตกต่างกัน จริง ๆ แล้วปัญญาประดิษเป็นคำกว้าง ๆ ที่มีเนื้อหามาจากหลักสูตรในวิชาวิทยาการคอมพิวเตอร์ (ตอนผมเรียนยังเป็นวิชาเลือกด้วยซ้ำ) ที่มีเนื้อหาว่าด้วยการเขียนโปรแกรมนั้นฉลาด เหมือนกับการสร้างวิธีการ (Algorithm) ให้มันเพื่อแก้ไขปัญหาต่าง ๆ คล้ายกับการสร้างปัญญาให้คอมพิวเตอร์อะไรทำนองนั้น ในนั้นก็มีวิธีการต่าง ๆ มากมายเพื่อให้มันฉลาดขึ้นเช่น การค้นหาระยะทางที่สั้นที่สุด การเรียงลำดับ การค้นหาตามแนวกว้าง แนวลึก การทำ Machine Learning ตัวแบบโมเดลต่าง ๆ Neural Network, Support Vector Machine เยอะแยะไปหมด สรุปก็คือถ้าเราสามารถทำให้โปรแกรมฉลาดและแก้ไขปัญหาให้เราได้ก็นับเป็น AI แล้ว แม้แต่การเขียนเงื่อนไข วนรอบซ้ำ รวม ๆ กัน ก็นับเป็น AI เหมือนกัน (ขอแค่มันฉลาดแก้ปัญหาได้) แต่ถ้าลงรายละเอียดแบบลึก ๆ ว่าจะทำยังไงให้มันเก่ง มันดี เรียนรู้เอง อันนี้มันเป็นแขนงหนึ่งแตกออกมาให้เรียนกันยันจบด็อกเตอร์กันเลย
ภาพรวมของ AI (ภาพจาก )
เมื่อก่อน (เมื่อก่อน ๆ ที AI ยังไม่บูม) เรื่องพวกนี้เป็นเรื่องที่ยาก มองเห็นภาพกันไม่ค่อยออก มีแต่เฉพาะในงานวิจัยเท่านั้น เพราะเมื่อก่อนเครื่องไม้เครื่องมือมันยังไม่ทันสมัย การประมวลผลตัว AI ที่เก่ง ๆ ต้องใช้ทรัพยากรณ์มหาศาล และใช้เวลานาน ๆ นานแบบเป็นปีถึงจะทำผลงานที่มีประสิทธิภาพออกมา และมันไม่คุ้มค่าในการทำ เลยไม่เป็นที่แพร่หลาย แต่การมาถึงของอุปกรณ์อย่างพวกการ์ดจอสมัยใหม่ ที่มีการประมวลผลแบบขนาน คือทำหลาย ๆ งานได้พร้อมกันในคราวเดียว ก็มาเปิดโลกของ AI โดยเฉพาะอย่างยิ่งในส่วนของการทำ Machine Learning ที่เป็นวิธีในการทำให้โปรแกรมเก่งขึ้นโดยการสอนข้อมูลเข้าไป มันก็เก่งขึ้นได้ เพราะพวกนี้ชอบการทำซ้ำ ๆ ยิ่งสอนเยอะก็ยิ่งฉลาด ถูกจริตกับการประมวลผลแบบขนานยิ่งนัก เราแยกข้อมูลกันประมวลผลได้เลย ไม่ต้องรอป้อนเข้าทีละอัน ทีนี้ความฉลาดของมันเลยเปลี่ยนจากหน้ามือเป็นหลังเท้าเลยก็ว่าได้ ตัวการ์ดจอมันพอหาซื้อได้ เข้าถึงได้ นักพัฒนาที่เก่ง ๆ สามารถพัฒนาขั้นตอนวิธีใหม่ ๆ เพื่อให้มันพัฒนาลำไปอีก ยุคหลังเราจึงเห็นได้ว่ามี AI เกิดขึ้นมามากมาย
ภาพแสดงให้เห็นถึงความแม่นยำของ AI ในการจำแนกภาพ เมื่อใช้ Deep Learning ที่รันใน GPU
ภาพจาก :
และก็เข้ามาสู่ยุคของ Edge AI / Edge Computing อย่างที่ได้กล่าวมา ในการประมวลผล AI นั้นเราจำเป็นต้องใช้การ์ดจอหรืออุปกรณ์เร่งการประมวลผล ที่แรงเร็ว มันจึงหนีไม่พ้นการทำเซิฟเวอร์และต้องเปิดไว้ตลอดเวลา จึงเป็นการลำบากที่เราจะพกพาความฉลาดนี้ติดตัวไปไหนมาไหน มันกลับกลายเป็นว่า ถ้าอยากใช้งานก็ต้องต่ออินเตอร์เน็ต ส่งข้อมูลไปประมวลผลแล้วค่อยส่งกลับมายังอุปกรณ์ปลายทาง จากที่ว่าประมวลผลได้รวดเร็ว ก็กลายเป็นช้าไป งานบางอย่างที่ต้องใช้ AI ตัดสินใจแบบทันทีก็ทำไม่มัน ยกตัวอย่างทำรถวิ่งอัตโนมัติ ตรวจเจอไฟแดงกว่าจะส่งข้อมูลไปประมวลผลส่งกลับมา รถชนกลางแยกพอดี นี่จึงเป็นปัญหาที่ทำให้เกิด AI on Edge ขึ้นมา คือการนำการประมวลผลมาไว้ที่อุปกรณ์ปลายทาง (Edge) แทนการทำในเซิฟเวอร์ ซึ่งก็ต้องขอบคุณเทคโนโลยีอีกนั้นแหละที่ทำให้เราสามารถผลิตไมโครชิป (Microchip) ที่ประมวลผลแบบขนานได้เหมือนกับการ์ดจอ ถึงจะไม่ได้เร็วเท่า แต่มันก็เอามาทำ AI ได้ ถึงแม้จะไม่ครอบคลุมเหมือนเครื่องใหญ่ ๆ แต่มันก็พกพาไปไหนมาไหนได้ ยกตัวอย่างก็เช่นพวกโทรศัพท์มือถือรุ่นใหม่ ๆ ที่บอกว่ากล้อง AI ก็ล้วนเอาชิปพวกนี้ทั้งสิ้น
ภาพการประมวลผลแบบ Edge AI ที่นำการประมวลผลไปไว้ยังอุปกรณ์ปลายทาง
ภาพจาก : Juven
CorgiDude ก็เป็นหนึ่งในอุปกรณ์เหล่านั้น (กริ่นซะยาว) มีความสามารถในการเร่งการประมวลผลคล้ายกับการ์ดจอ แต่ถอดออกมาเฉพาะบางส่วน ทำให้สามารถทำงาน AI บางอย่างได้เช่น ตรวจจับใบหน้า รู้จำใบหน้า จำแนกวัตถุ รู้จำเสียง ค้นหาวัตถุได้ เป็นต้น ซึ่งทำงานในตัวอุปกรณ์เองได้เลยไม่ต้องส่งข้อมูลไปไหน และความเร็วยังอยู่ในระดับดีน่าพอใจเลยทีเดียว (จำแนกรูปขนาด 224x224 ในระดับ 10 - 20 รูปต่อวินาทีได้) หัวใจหลักของมันคือชิป Kendryte K210 มีความเร็วในการประมวลผลอยู่ที่ 1 TOPS ที่ 108MHz + Flash 16Mbyte (Tera Operations Per Second : 1 ล้านล้าน การประมวลผล ใน 1 วินาที) แต่มันกินไฟแค่ 0.3W ซึ่งชิปตัวนี้ถูกผลิตขึ้นโดยบริษัท Canaan ที่หลัก ๆ ทำงานด้าน Blockchain (ชิปขุด Bitcoin ประมาณนั้น) ใช้สถาปัตยกรรม RISC-V Dual Core 64bit, with FPU ขนาด 28nm ในชิปมีหน่วยประมวลผล KPU สำหรับการทำ Convolutional Neural Network (CNN) บนอุปกรณ์ฮาร์ดแวร์ สำหรับทำ Machine Learning ในขณะที่ตัวมันเองกินไฟแค่ 3.3v นอกจากนั้นมันยังมีส่วนประกอบอื่นในการเป็น Microcontroller ไว้ครบเช่น GPIO, UART, SPI และพอร์ดสำหรับต่อกล้องกับจอเอาไว้ให้ครบเลยทีเดียว
ภาพแสดงโครงสร้างของชิป Kendryte K210
ชิปตัวนี้ถูกบริษัท Sipeed นำมาลงโมดูลให้ใช้งานง่ายมากขึ้น มีการใส่ชิป ESP8285 ทำให้สามารถต่อ WiFi เชื่อมต่ออินเตอร์เน็ตได้ มีการพัฒนา SDK ต่อยอดจากเดิมเพื่อเพิ่มประสิทธิภาพ และพัฒนา IDE ต่อจาก OpenMV เพื่อให้ micropython บนอุปกรณ์ตัวนี้ได้ (เดี๋ยวรายละเอียดแบบลึก ๆ เกี่ยวกับ Sipeed จะมาเล่าให้ฟังอีกรอบ)
CorgiDude นั้นนอกจาก Chip AI แล้วยังได้ถูกออกแบบมาสำหรับการต่อและใช้งานเกี่ยวกับงานด้าน Microcontroller IoT ด้วย
* **ช่องต่อ Input** พอร์ตสำหรับต่อเซนเซอร์ที่อ่านค่าได้ เช่นอุณหภูมิ ความชื้น ความเร็วความเร่ง แรงดันไฟฟ้า โดยจะมีทั้งหมด 2 ช่อง (INPUT1 และ INPUT2) ช่องละ 5 GPIO นับรวมไฟเลี้ยง 3.3v รวมเป็น 7 Pin รวมกันแล้วสามารถใช้ GPIO ได้ทั้งหมด 10 Pin
* **ช่องต่อ Output** มีลักษณะคล้ายกันกับ Input แต่ใช้สำหรับต่ออุปกรณ์ Output เช่นควบคุมมอเตอร์ เซอร์โวมอเตอร์ ปิดเปิด Relay โดยช่อง Output จะมี 2 ช่อง คือ OUTPUT1 และ OUTPUT2 แต่ละช่องจะมี GPIO ทั้งหมด 4 ตัว และไฟเลี้ยง 2 ขา รวมเป็น 6 ขา รวมแล้วใช้ GPIO ได้ทั้งหมด 8 Pin ด้วยกัน
* **ช่องต่อกล้อง** จะมีคำว่า “CAMERA” เขียนกำกับไว้ โดยกล้องที่รองรับจะเป็นรุ่น OV2640 24Pin
* **ช่องต่อจอภาพ** จอภาพที่ต่อได้จะเป็นรุ่น ST7789 การต่อคล้ายกันกับการต่อกล้อง คือจะมีคอนเน็คเตอร์เขียนว่า “DISPLAY” กำกับเอาไว้
* **ช่องต่อไฟเลี้ยง** ไฟเลี้ยงบอร์ดสามารถใช้ไฟจาก USB 5V หรือเลือกเสียบ Adaptor ที่จ่ายไฟเลี้ยงได้ตั้งแต่ 6-18V DC โดยใช้แจ็คขนาดประมาณ 2x5.5mm (หาซื้อได้ทั่วไป)
* ปุ่มกด
ปุ่มกดในบอร์ดจะมีทั้งหมด 2 ปุ่มคือ
* RESET ใช้สำหรับกด reset บอร์ดให้เริ่มทำงานใหม่
* BOOT ใช้สำหรับกดเพื่อควบคุมการเข้า Boot โหมด หรือ สั่งทำงานต่าง ๆ โดยต่อไว้กับ GPIO 16
* **ช่องเสียบ Micro-SD** ใช้สำหรับการโหลดไฟล์หรือบันทึกไฟล์ต่าง ๆ
* **หลอดไฟ RGB** สำหรับแสดงสถานะต่าง ๆ
สำหรับเรื่องราวของบอร์ด CorgiDude คร่าว ๆ ก็จะประมาณนี้ ในบทความหน้าเราจะมาลงรายละเอียดในเรื่องของการใช้งานและพอร์ตแต่ละอันกันครับ
# Specification
**ชุดอุปกรณ์ที่ได้รับในแต่ละรุ่น**
| **Basic** | **Lite** | **IoT** |
| ---------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| CorgiDude รุ่นเริ่มต้นสำหรับรียน Machine Learning | CorgiDude และเซ็นเซอร์ครบชุดลงกล่อง ไม่มีโมดูล WiFi | CorgiDude และเซ็นเซอร์ครบชุดลงกล่อง มี WiFi ทำ IoT ได้ |
| - บอร์ด CorgiDude แบบไม่มี WiFi
- โมดูลกล้อง OV2640 2MP
- โมดูลจอสี 1.3 นิ้ว IPS 240x240
- เคสอะคริลิค ชุดน๊อต และ ไขควง
| - บอร์ด CorgiDude แบบไม่มี WiFi
- โมดูลกล้อง OV2640 2MP
- โมดูลจอสี 1.3 นิ้ว IPS 240x240
- เคสอะคริลิค ชุดน๊อต และ ไขควง
- เซ็นเซอร์วัดอุณหภูมิ ความชื้น AHT10
- เซ็นเซอร์วัดค่าแรงดัน Anolog 16bit
- โมดูลขับมอเตอร์ 2 ช่องอิสระ
- โมดูลต่อ GPIO/Servo 4 ช่อง
- โมดูลต่อ GPIO Input 5 ช่อง
- สายแพ FFC 12 และ 20 cm
| - บอร์ด CorgiDude เชื่อมต่อ WiFi ได้
- โมดูลกล้อง OV2640 2MP
- โมดูลจอสี 1.3 นิ้ว IPS 240x240
- เคสอะคริลิค ชุดน๊อต และ ไขควง
- เซ็นเซอร์วัดอุณหภูมิ ความชื้น AHT10
- เซ็นเซอร์วัดค่าแรงดัน Anolog 16bit
- โมดูลขับมอเตอร์ 2 ช่องอิสระ
- โมดูลต่อ GPIO/Servo 4 ช่อง
- โมดูลต่อ GPIO Input 5 ช่อง
- สายแพ FFC 12 และ 20 cm
|
\
**รายละเอียดโมดูลต่าง ๆ (รายการของแต่ละรุ่นดูได้จากด้านบน)**\
| **โมดูลกล้อง** | **โมดูลจอภาพ** | **โมดูลวัดอุณหภูมิความชื้น** |
| ------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
| กล้อง OV2640 ความละเอียดสูงสุด 2MP ออกแบบสำหรับยึดในบอร์ดหรือสามารถต่อสายยาวได้ติดตั้งง่าย | จอภาพขนาด 1.3 นิ้ว ความละเอียด 240x240 Pixel จอสี IPS แสดงภาพได้สว่างคมชัด มุมมองกว้าง | AHT10 วัดอุณหภูมิและความชื้นความแม่นยำสูง (อุณหภูมิ 0.01% ความชื้น 0.024%) |
|  |  |  |
| **โมดูลอ่านแรงดันอนาล็อค** | **โมดูลขับมอเตอร์** | **โมดูล GPIO** |
| สำหรับอ่านเซนเซอร์ต่าง ๆ เช่น แรงดันไฟ ความชื้นในดิน แสงสว่าง ความละเอียด 16 บิต 8 ช่อง | ขับมอเตอร์ 2 channel กระแสต่อเนื่อง 3A Peak 5A บังคับหมุนไปหน้าย้อนกลับอิสระต่อกัน นำไปทำรถได้ง่าย | - Input สำหรับอ่านค่า Digital เช่นปุ่มกด PIR / Output สำหรับสั่งเขียน Digital เช่น Servo Relay |
|  |  |  |
\
\
**!!! ของแถมฟรี !!!** \
\+ (เฉพาะ IoT และ Lite) สายแพ FFC สำหรับต่อจอ/กล้อง ยาว 12cm 1เส้น (ราคาปกติ 50 บาท)\
\+ (เฉพาะ IoT และ Lite) สายแพ FFC สำหรับต่อจอ/กล้อง ยาว 20cm 1เส้น (ราคาปกติ 60 บาท)
+เคสอะคริลิคสีดำทุกรุ่น พร้อมน๊อตยึดพลาสติก (ราคาปกติ 65 บาท)\
+ไขควงและเอกสารในการประกอบเคส\
\
\
\
## รายละเอียดทางเทคนิค
**- Module Kendryte K210** \
Dual-Core 64-bit RISC-V RV64IMAFDC (RV64GC) CPU / 400Mhz(Normal)\
Dual Independent Double Precision FPU\
8MiB 64bit width On-Chip SRAM\
Neural Network Processor(KPU) / 0.8Tops\
Field-Programmable IO Array (FPIOA)\
Dual hardware 512-point 16bit Complex FFT\
SPI, I2C, UART, I2S, RTC, PWM, Timer Support\
AES, SHA256 Accelerator\
Direct Memory Access Controller (DMAC)\
Micropython Support\
Firmware encryption support\
\
**กล้อง : OV2640** \
2 Megapixel\
Array size: UXGA 1622X1200\
Power supply: 3.3V\
IO voltage level: 1.7V\~3.3V DC\
Output formats:\
YUV(422/420)/YCnCr422\
RGB565/555\
8-bit compressed data\
Max image transfer rate:\
UXGA/SXGA 15fps\
UXGA/SXGA 30fps\
SVGA 30fps\
CIF 60fps\
\
**จอ ST7789 :**
1.3″ IPS LCD with wide ±80° viewing angle\
RGB Full color display\
240 x 240 high resolution 260PPI display\
SPI interface w/out CS pin\
ST7789 LCD display controller\
3.3 operation
**โมดูล WiFi : ESP8285** (เฉพาะรุ่น IoT)\
Tensilica L106 32-bit MCU\
Wireless Standard 802.11 b/g/n\
Frequency Range 2400Mhz - 2483.5Mhz\
TX Power(Conduction test) 802.11.b : +15dBm\
802.11.g : +10dBm(54Mbps)\
802.11.n : +10dBm (65Mbps)\
Antenna Connector IPEX 3.0x3.0mm\
Wi-Fi mode Station/SoftAP/SoftAP+Station
# Installation
# การใช้งาน Maixpy IDE เบื้องต้น
สวัสดีครับ หลังจากที่เราได้ อัพโหลดโปรแกรม MaixPy.bin ลงไปยัง CorgiDude บอร์ด แล้ว แปลว่า CorgiDude บอร์ด นั้นก็สามารถรัน micropython ได้แล้วผ่านทาง serial port ที่ได้ต่อกับคอมพิวเตอร์ของเรานะครับ เราสามารถพิมพ์คำสั่งผ่านทาง serial port ได้เลยครับ แต่มันก็ยากอยู่ดีทาง sipeed ก็ได้ทำ IDE ขึ้นมา ชื่อว่า MaixPy IDE โหลดได้จากที่นี้ อาจจะช้าหน่อยนะครับ พอลงเสร็จก็จะได้ maixpyide.exe มานะครับ ก็เข้าโปรแกรมได้เลยครับ
ก็จะได้หน้าตาแบบนี้ขึ้นมาครับ ต่อไปก็ไปดูตำแหน่ง File ได้เลยครับว่ามีอะไรบ้าง
New File คือ เปิดหน้าใหม่ Open File คือ เปิดไฟล์ที่เคยบันทึกไว้ Example คือ ตัวอย่าง Recent File คือ ไฟล์ที่เคยเปิด แล้วก็มีคำสั่งมาตราฐาน ทั่วไปอื่นๆ
ต่อไปเป็น Edit
มีคำสั่งมาตราฐาน ทั่วไปอื่นๆ แล้วก็คีย์ลัดต่างๆ
ต่อไป Tools อันนี้สำคัญ มาก (ถ้าใช้ CorgiDude บอร์ด ให้เลือก Sipeed Maix Dock)
อันแรก Select Board คือ การเลือก บอร์ด ต่างๆ ถ้าเราใช้ บอร์ดไหนก็เลือกให้ตรงนะครับ ถ้าไม่ตรงมันอาจจะใช้ไม่ได้ครับ
Open Terminal คือ ดูว่ามี Serial Port ไหนบ้างที่ต่อกับคอมอยู่
Machine Vision คือเครื่องมือที่โปรแกรมให้มา เลือกใช้ได้เลยครับ
ส่วนนี้เป็นหน้าต่าง สตรีม รูปจาก ตัวบอร์ด กด Zoom ได้ Disable ได้
ส่วนต่อไปเป็นพื้นที่เขียนโปรแกรมนะครับ
ต่อไปเป็น Serial ที่ส่งมาจากบอร์ด
ต่อไปตรงนี้เป็น ปุ่มเชื่อมต่อกับบอร์ด
และ ปุ่มรันโปรแกรม จากตรงนี้ได้เลย ต่อไปก็จะรันตัวอย่างให้ดูนะครับ
หวังว่าบทความนี้จะมีประโยชน์ กับผู้อ่านนะครับ ถ้าพิมพ์ผิดไปขออภัย ณ ที่นี้ด้วยนะครับ (เขียนโดย นายอภินันท์ บุญทอง)
# วิธีการลง Maixpy ใน Sipeed Maix Bit
สวัสดีครับ บทความนี้จะมาพูดถึงเรื่องของ K210 หรือ sipeed maix bit พอดีผมได้ลองใช้งาน MAIXPY ใน k210 นะครับ
kendryte k210 คืออะไร
เป็น IC คล้ายๆ กับไมโคร หรือ esp32 แต่ K210 ไม่มี wifi ให้ใช้งาน แต่มี KPU สำหรับประมวลผม AI ได้ 230GOPs แล้วก็มี kendryte IDE ที่ทาง kendryte ทำมาให้ใช้งาน [https://kendryte.com/ ](https://kendryte.com/)ลิ้งให้ศึกษาข้อมูล ต่อมาก็มี sipeed ซื้อ IC มาทำบอร์ดให้ใช้งาน มี sipeed maix bit ,Sipeed MAIX GO , Sipeed M1w Dock และอื่นๆ ยังไม่หมดนะครับว่า sipeed ทำอะไรบ้าง sipeed ได้ สร้าง maixpy ที่เป็น micropython มาให้เราได้ใช้งานด้วย แล้วมี maixduino ที่สามารถเขียนโปรแกรมด้วย arduino ide ก็ยังได้นะครับ ดังนั้น ไม่ว่าใครจะถนัด python ก็เขียนได้เลย หรือจะถนัด arduino ide ก็ยังได้นะครับเห็นแล้วครอบคลุม ทุการใช้งาน
ต่อไปมาดู คุณสมบัติ ของตัว k210 กันได้เลยครับ
สถาปัตยกรรมแบบ RISC-V 64 bit IMAFDC แบบ dual-core มี KPU (หน่วยประมวลผล neural network) ภายในขนาด 64 KPU ( 576bit) ที่ 230GOPs ความถี่ 400MHz SRAM ความเร็วสูงสุด 8MB กินพลังงานสูงสุดเพียง 1W รองรับการใช้งาน AI และ IOT บางโมดูล นะครับ หลังจากที่ได้รู้ข้อมูลเบื่องต้นแล้ว อลังการ มากเลยครับ
ต่อไปมาดู sipeed maix bit กันบ่างว่ามีอะไรติดมาบ้าง
ตามรูปเลยครับ คล้าย arduino nano ด้วยนะครับ เจ้าตัว sipeed maix bit ตัวนี้สามารถต่อ กล้องได้ ต่อ จอLCD ก็ได้ด้วยนะครับ เหมาะกับเอามาทำ AI ขนาดเล็ก สั่นมากขายเป็นชุด ตามรูปเลยครับ
ดูจากรูปแล้ว มีกล้อง จอ แล้วก็มี IO ให้ใช้งานได้เลยด้วย แล้วก็ลองคิดเล่นๆ ว่าจะเอาไปใช้ทำโปรเจค อะไรได้มากมาย เช่น
เครื่องมือตรวจจับสัตว์และไล่สัตว์ เครื่องให้อาหารสัตว์แล้วก็แยกด้วยว่าจะใช้สัตว์ตัวไหน เครื่องเปิดประตูด้วยใบหน้า เครื่องรดน้ำต้นไม้ด้วยกล้องก็ยังได้ เป็นต้น นะครับ
พอละ โม้มาเยอะแล้ว มาเข้าเนื้อหากันเลยดีกว่า บทความนี้มาสอนลง maixpy ใน sipeed maix bit
โหลดโปรแกรม kflash\_gui มาก่อนนะครับ หาได้จากลิ้ง โหลดมาก็เปิดใช้งานได้เลยครับ ถ้าได้เข้าโปรแกรมหน้าตาก็ตามรูปเลยครับ
ต่อไป โหลดไฟล์ .bin จากลิ้ง ตัวนี้เป็น maixpy ตัวใหม่ที่รองรับโมเดล V4 ที่พี่ตูมตามได้ บิวมาให้เลยครับ
ต่อไป หลังจากที่เราได้เป็ดโปรแกรมมาแล้ว
เปิดไฟล์ .bin ที่ให้โหลดมาเลยครับ
ปรับ Board เป็น Auto
เปลี่ยน Port เป็น Port ของ บอร์ท ที่เราได้ต่ออยู่
กด Download
รอจนกว่าจะโหลดข้อมูลเสร็จ
ขึ้นแบบนี้แปลว่าเสร็จแล้ว
จบแล้วครับ แค่นี้เราก็ได้ [maixpy](https://github.com/cmmakerclub/maixpy_kmodel_v4_support) มาแล้วครับ บทความต่อไปก็จะเป็นบทความการใช้งาน [maixpy IDE ](https://github.com/cmmakerclub/maixpy_kmodel_v4_support) นะครับรอติดตามกันได้เลยครับ
และสุดท้ายก็ขออภัยถ้าพิมผิดหรืออ่านไม่เข้าใจด้วยนะครับ(เขียนโดย นายอภินันท์ บุญทอง)
# การใช้งาน Kflash GUI และการอัพโหลดไฟล์ .bin kmodel
ในการที่เราจะ flash K210 นั้นจะต้องใช้โปรแกรม kflash\_gui เราสามารถไปโหลดได้จากข้างล่างต่อไปนี้โหลด Firmware MaixPy (ตัวนี้รองรับโมเดล V4) ได้จากที่นี้
โปรแกรม kflash\_gui
โหลดได้จากที่นี้
ลง Firmware MaixPy ในตัว บอร์ด ก่อนโดย
เปิดโปแกรม kflash\_gui
Open File แล้วเลือกไฟล์ Firmware MaixPy ที่ให้ไปโหลดมามีชื่อว่า corgidude\_firmware\_full.bin ประมาณนี้
เลือก Port ให้ตรงกับบอร์ดของเรา แล้ว Download เลย
รอ จนกว่าจะเสร็จ แล้วจะขึ้น Downlond success แปลว่าเสร็จแล้ว OK
ต่อไป เรื่อง kmodel kmodel นั้นจะให้รันบนตัว k210 นั้น ตอนรันสคริป นั้นก็จะต้องมีการโหลด kmodel มาได้ 2 ทาง
ทางที่ 1 คือ อ่านจาก sd card เราก็เอา ไฟล์ kmodel วางใว้ใน sd card ได้เลย
ทางที่ 2 คือ อ่านจาก flash ภายใน บอด์ท การที่จะนำเอา kmodel นั้นลงไปยัง flash ก็ต้องใช้ kflash\_gui เหมือนกัน ตามรูปเลยครับ
เจ้าเลข 0x400000 เป็นตำแหน่งที่เราเอา model เขียนลงไปครับ เวลาอ่าน ก็ต้องอ่าน จากตำแหน่งที่เราเขียนลงไปนะครับ
แล้วกด Download ได้เลยครับ
รอ จนกว่าจะเสร็จ แล้วจะขึ้น Downlond success แปลว่าเสร็จแล้ว OK
# Lessons
**ตอนที่ 1 - CorgiDude รีวิวอุปกรณ์เบื้องต้น บอร์ดคอร์กี้ดู๊ดสำหรับทำ AI Machine Learning**
{% embed url="" %}
**ตอนที่ 2 - CorgiDude รู้จักกับบอร์ด AI คืออะไร เป็นมายังไง คอร์กี้ดู๊ดสำหรับทำ AI Machine Learning**
{% embed url="" %}
**ตอนที่ 3 - CorgiDude การติดตั้ง Firmware, IDE และทดสอบใช้งาน บอร์ดคอร์กี้ดู๊ดทำ AI Machine Learning**
{% embed url="" %}
**ตอนที่ 4 - CorgiDude การใช้งาน GPIO อ่านอุณหภูมิความชื้น ขับเซอร์โว มอเตอร์ สำหรับทำ AI Machine Learning**
{% embed url="" %}
**ตอนที่ 5 - CorgiDude การเขียน Python เพื่อประมวลผลรูปภาพ การหาวงกลม สีเหลี่ยม เส้น QRCode จะจับสีวัตถุ**
{% embed url="" %}
**ตอนที่ 6 - CorgiDude การจำแนกรูปภาพโดยใช้โมเดล MobileNet จำแนกรูปภาพ 1000 ชนิด**
{% embed url="" %}
**ตอนที่ 7 - การสอน AI Model จำแนกภาพขยะโดยใช้วิธี Transfer Learning**
{% embed url="" %}
**ตอนที่ 8 - จำแนกรถบนถนน โดยเริ่มสอน MobileNet ตั้งแต่ต้น**
{% embed url="" %}
**ตอนที่ 9 - ค้นหาและจำแนกวัตถุในภาพด้วย YOLO Object Detection**
{% embed url="" %}
**ตอนที่ 10 - ค้นหาใบหน้าในภาพด้วย YOLO - Face Detection**
{% embed url="" %}
# Article & API
# การใช้งาน GPIO
การใช้งาน GPIO ของบอร์ด CorgiDude นั้นก็จะมีที่ให้ใช้งานอยู่ 4 จุดด้วยกันนะครับ
จากรูปภาพข้างต้น จะมี INPUT 2 จุด OUTPUT 2 จุด INPUT 1 มี 11-15 เป็นชื่อขาใช้งานนะครับ INPUT 2 มี 1-3,10 เป็นชื่อขาใช้งานนะครับ OUTPUT 1 มี 18-21 เป็นชื่อขาใช้งานนะครับ OUTPUT 2 มี 32-35 เป็นชื่อขาใช้งานนะครับ
เมื่อเราได้รู้จักการกับขาต่างๆ แล้ว ต่อไปก็มาดูโปแกรมกันเลยครับ ในที่นี้จะใช้เป็น micropython นะครับ
ในที่นี้ผมจะใช้ โมดูล Buttun ตัวนี้ในการแนะนำการใช้งานนะครับ
หาซื้อได้จาก ได้เลยครับ
โมดูลตัวนี้ active high
ต่อ โมดูลเข้ากับ CorgiDude เลือก INPUT 1 เลยนะครับ
หลังจากต่อเสร็จ มาดูโปรแกรมกันต่อครับ
```
import utime
from Maix import GPIO
from board import board_info
from fpioa_manager import fm
```
ข้อความข้างบนเป็น เรียกใช้ library ในที่นี้ก็จะมี utime เวลาที่นับขึ้นตั้งแต่เปิดเครื่อง GPIO คือ GPIO ให้ใช้งาน
```
#board_info คือ ใช้ที่ใช้แทงขา
#fm คือ ตัวจอง GPIO ภายใน
fm.register(11, fm.fpioa.GPIOHS0, force=True)
fm.register(12, fm.fpioa.GPIOHS1, force=True)
fm.register(13, fm.fpioa.GPIOHS2, force=True)
fm.register(14, fm.fpioa.GPIOHS3, force=True)
fm.register(15, fm.fpioa.GPIOHS4, force=True)
#เป็นการตั้งค่า GPIO ภายในกับภายนอก
#ภายนอกเป็น 11,12,13,14,15 เป็นต้น
#ภายในเป็น fm.fpioa.GPIOHS0,fm.fpioa.GPIOHS1,fm.fpioa.GPIOHS2 เป็นต้น
input11 = GPIO(GPIO.GPIOHS0, GPIO.IN)
input12 = GPIO(GPIO.GPIOHS1, GPIO.IN)
input13 = GPIO(GPIO.GPIOHS2, GPIO.IN)
input14 = GPIO(GPIO.GPIOHS3, GPIO.IN)
input15 = GPIO(GPIO.GPIOHS4, GPIO.IN)
#ต่อไปกำหนดว่าเป็น INPUT หรือ OUTPUT
GPIO.IN คือ กำหนดให้เป็น INPUT
GPIO.OUT คือ กำหนดให้เป็น OUTPUT
while 1:
print("input:", input11.value(), input12.value(), input13.value(), input14.value(), input15.value())
utime.sleep_ms(500)
#แสดงผมทุกขาออกมา
input11.value() คือ การดึงค่า INPUT มาแสดงได้
input11.value(0) คือ การกำหนด ลอจิก 0 ไปยัง input11 นั้นเอง
#ดังนี้ถ้าเอาโปรแกรมมาต่อรวมกับ
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
import utime
from Maix import GPIO
from board import board_info
from fpioa_manager import fm
fm.register(11, fm.fpioa.GPIOHS0, force=True)
fm.register(12, fm.fpioa.GPIOHS1, force=True)
fm.register(13, fm.fpioa.GPIOHS2, force=True)
fm.register(14, fm.fpioa.GPIOHS3, force=True)
fm.register(15, fm.fpioa.GPIOHS4, force=True)
input11 = GPIO(GPIO.GPIOHS0, GPIO.IN)
input12 = GPIO(GPIO.GPIOHS1, GPIO.IN)
input13 = GPIO(GPIO.GPIOHS2, GPIO.IN)
input14 = GPIO(GPIO.GPIOHS3, GPIO.IN)
input15 = GPIO(GPIO.GPIOHS4, GPIO.IN)
while 1:
print("input:", input11.value(), input12.value(), input13.value(), input14.value(), input15.value())
utime.sleep_ms(500)
///////////////////////////////////////////////////////////////////////////////////////////////////////////
```
ก็จะได้โปรแกรมอ่านค่า Button ทั้งโหมดในโมดูล
หลังจากนี้ ผมจะให้ โจทย์ ลองเขียนแสดง หลอดไป LED RGB แบบกระพริบพร้อมกับ ที่อยู่บนบอด์ทโดย ขา R=22,G=24,B=23 ใช้ทำ 10 นาทีครับเริ่มครับ
# การอ่านและเขียนไฟล์ SD Card
สวัสดีครับ วันนี้ผมจะมาพูดเรื่องการใช้งาน **CorgiDude บอร์ด กับการใช้งาน อ่านและเขียนไฟล์ใน SD Card** ติดมานะครับ การใช้งานการอ่านก่อนเลยนะครับ
การใช้งาน SD Card นั้นต้องใส่ SD Card ก่อนนะครับ เมื่อทำการต่อเสร็จแล้ว
ต่อไปมาดูโปรแกรม ตัวอย่าง
การอ่าน SD card ก่อนเลยนะครับ การอ่าน SD card นั้นผมจะมาสอนอยู่ 2 อย่างครับอย่างที่่ 1 อ่านรูปจาก SD card อย่างที่่ เป็นการอ่านไฟล์ txt เรามาเริ่มอ่านรูปจาก SD card ก่อนเลยครับ ก่อนอื่นก็เตรียมรูปผมแนะนำให้เป็นไฟล์ jpg นะครับนำไปใส่ใน SD card ไว้ได้เลยครับ หลังจากที่เราได้เอารูปใส่ใน SD card แล้วให้เราจำชื่อไฟล์รูปของเราด้วยนะครับเพื่อเอาไปใช้งานตอนไหน script เราจะได้นำชื่อรูปใส่ในคำสั่งอ่านรูปครับ
```
img = image.Image("/sd/33.jpg")
```
จากคำสั่งข้างบน อ่านรูปชื่อ 33.jpg ใน SD นะครับ
```
import sensor, image, time,lcd
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.skip_frames(time = 2000)
lcd.init(type=2, freq=20000000, color=lcd.BLACK)
clock = time.clock()
while(True):
clock.tick()
#img = sensor.snapshot()
img = image.Image("/sd/33.jpg")
lcd.display(img)
print(clock.fps())
```
สิ่งที่สำคัญ รูปไม่ควรใหญ่กว่าจอ นะครับ ถ้าใหญ่ได้แต่ต้องรีขนาด และถ้าใหญ่เกินแรมจะไม่พอนะครับ ต่อไปมาดูตัวอย่างการอ่านไฟล์ TXT ต่อกันเลยนะครับ นำไฟล์ .txt ที่เราจะอ่านไปใว้ใน SD ครับ ไฟล์ของผมชื่อ test.txt โปรแกรมตัวอย่างครับ
```
import sensor, image, time,lcd
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.skip_frames(time = 2000)
lcd.init(type=2, freq=20000000, color=lcd.BLACK)
clock = time.clock()
f=open('/sd/test.txt','r')
labels=f.read()
f.close()
img = image.Image()
img.draw_string(0, 0, labels, scale=1)
lcd.display(img)
```
ต่อไปมาดูวิธีการบันทึกรูปลงใน SD กันครับ
```
a = img.save("/sd/test.jpg")
import sensor, image, time,lcd
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.skip_frames(time = 2000)
lcd.init(type=2, freq=20000000, color=lcd.BLACK)
clock = time.clock()
mun = 0
while(True):
clock.tick()
img = sensor.snapshot()
#img = image.Image("/sd/33.jpg")
mun = mun+1
img.save("/sd/"+str(mun)+".jpg")
lcd.display(img)
print(clock.fps())
```
โปรแกรมตัวนี้บันทึกรูปไปเรื่อยๆๆโดยผมเปลียนชื่อครับ
ต่อไปผมจะมาให้ตัวอย่าโปรแกรมเขียนไฟล์ .csv นะครับ อันดับแรไปสร้างไฟล์ .csv ใน SD ก่อนครับตั้งชื้ออะไรก็ได้ครับ ยิ่งสั่นยิ่งดีครับ ของผม เป็น test.csv แล้วกันครับ
```
import os
import time
f = open('/sd/test.csv', 'a')
deta =0
deta2 =0
deta3 =0
while True:
deta = deta+1
deta2 = deta2+2
deta3 = deta3+3
f.write(str(deta)+","+str(deta2)+","+str(deta3)+"\n")
f.flush()
time.sleep(1)
```
# การเชื่อมต่อ WiFi
หลังจากที่ได้ลองเขียนโค๊ดลง CorgiDude กันไปแล้ว วันนี้เรามาเพิ่มความสามารถ เชื่อมต่อ WiFi กันดูดีกว่าครับ!
เนื่องจาก CorgiDude ใช้ Sipeed K210 Module ที่มี chip ESP8285 อยู่ในนั้นด้วย เราจึงสามารถประมวลผล AI และเชื่อมต่อ Internet ผ่าน WiFi กันได้ แบบครบเครื่องบน CorgiDude ตัวเดียวเลยครับ
ภาพ Sipeed Module
เริ่มเชื่อมต่อ WiFi! เริ่มต้นด้วยการ Select Board ให้เป็น Sipeed Maix Dock
มาเริ่มโค๊ดกันเลย!
```
from Maix import GPIO
from machine import UART
from fpioa_manager import fm, board_info
import lcd, image
import usocket, network, time
fm.register(8, fm.fpioa.GPIOHS0)
wifi_en=GPIO(GPIO.GPIOHS0,GPIO.OUT)
fm.register(board_info.WIFI_RX,fm.fpioa.UART2_TX)
fm.register(board_info.WIFI_TX,fm.fpioa.UART2_RX)
counter = 1
line_height = 20
WIFI_SSID = "CMMC_3BB_2.4GHz"
WIFI_PASS = "xxxxxxxxxx"
lcd.init(type=1, freq=15000000)
lcd.freq(16000000)
def draw_line(text, color=lcd.RED):
global counter
lcd.draw_string(0, line_height*counter, text, color, lcd.BLACK)
counter += 1
def wifi_enable(en):
global wifi_en
wifi_en.value(en)
#draw_line("wifi_en({})".format(en))
def wifi_reset():
global uart
print("wifi reset")
wifi_enable(0)
time.sleep_ms(200)
wifi_enable(1)
time.sleep_ms(200)
uart = UART(UART.UART2,115200,timeout=1000, read_buf_len=1024)
tmp = uart.read()
time.sleep_ms(200);
print(uart.read())
uart.write("AT\r\n")
tmp = uart.read()
if tmp and not tmp.endswith("OK\r\n"):
draw_line("reset failed")
print("reset fail")
return None
try:
nic = network.ESP8285(uart)
#draw_line("NIC OK!", lcd.GREEN)
except Exception:
return None
return nic
draw_line("CorgiDude!", lcd.YELLOW)
time.sleep(2)
draw_line("Preparing NIC...")
nic = wifi_reset()
if not nic:
draw_line("WiFi init fail!")
raise Exception("WiFi init fail")
else:
draw_line("Connectin to WiFi...")
nic.connect(WIFI_SSID, WIFI_PASS)
ip,subnet,gateway,dns,b,mac,ssid = nic.ifconfig()
print("WiFi Connected. ip={}, gateway={}".format(ip,gateway))
draw_line("WiFi Connected.", lcd.GREEN)
draw_line("")
draw_line("ip={}, gateway={}".format(ip,gateway), lcd.YELLOW)
draw_line("mac={}, ssid={}".format(mac,ssid), lcd.YELLOW)
```
# การใช้งาน HTTP Request
การเราจะไปทำ IoT Project กับ Corgidude ด้วยโพรโตคอลยอดนิยมกับ MQTT กัน เรามาเริ่มกันแบบง่ายๆไปกับการสร้าง HTTP Request กันนะครับ
เริ่มต้นด้วยการโหลด library ที่ชื่อว่า urequest.py มาเป็นตัวช่วยสำหรับการทำ HTTTP Request ให้ CorgiDude ของเราครับ ซึ่ง [**คลิ๊กเพื่อโหลดได้ที่นี่เลย!**](https://gist.github.com/NAzT/5821cacdb98d9eb28d30a597186e4be1/archive/91cd28ae2389168f02a39c4ded0c12c02d0d1252.zip) หลังจากนั้นโยนไฟล์เข้าไปในบอร์ด CorgiDude โดยการเลือก Tools > transfer file to board
เลือกไฟล์ > อัพโหลดไฟล์เข้าไปในบอร์ด > รอจนขึ้นว่า **save file OK**
หลังจากนั้นเราก็มาเขียนโค๊ดกันเลย!
```
import network, time
import time
from Maix import GPIO
from machine import UART
from fpioa_manager import fm, board_info
import lcd, image
import usocket, network, time
import urequests as request
WIFI_SSID = "LiLy_2.4G"
WIFI_PASS = ""
counter = 1
line_height = 20
lcd.init(type=1, freq=15000000)
lcd.freq(16000000)
def draw_line(text, color=lcd.RED):
global counter
lcd.draw_string(0, line_height*counter, text, color, lcd.BLACK)
counter += 1
draw_line("CorgiDude!", lcd.YELLOW)
time.sleep(2)
draw_line("Setting up gpios", lcd.YELLOW)
fm.register(0, fm.fpioa.GPIOHS1, force=True)
wifi_io0_en=GPIO(GPIO.GPIOHS1, GPIO.OUT)
fm.register(8, fm.fpioa.GPIOHS0)
wifi_en=GPIO(GPIO.GPIOHS0,GPIO.OUT)
fm.register(board_info.WIFI_RX,fm.fpioa.UART2_TX)
fm.register(board_info.WIFI_TX,fm.fpioa.UART2_RX)
def wifi_enable(en):
global wifi_en
wifi_en.value(en)
draw_line("Preparing NIC...")
uart = UART(UART.UART2,115200,timeout=1000, read_buf_len=4096)
wifi_enable(0)
time.sleep_ms(200)
wifi_enable(1)
def wifi_reset():
global uart
print("wifi reset")
wifi_enable(0)
time.sleep_ms(200)
wifi_enable(1)
time.sleep(2)
uart = UART(UART.UART2,115200,timeout=1000, read_buf_len=1024)
tmp = uart.read()
uart.write("AT+UART_CUR=921600,8,1,0,0\r\n")
time.sleep_ms(200);
print(uart.read())
uart = UART(UART.UART2,921600,timeout=1000, read_buf_len=10240) # important! baudrate too low or read_buf_len too small will loose data
time.sleep_ms(200);
print(uart.read())
uart.write("AT\r\n")
tmp = uart.read()
print(tmp)
if tmp and not tmp.endswith("OK\r\n"):
print("reset fail")
return None
try:
nic = network.ESP8285(uart)
except Exception:
return None
return nic
nic = wifi_reset()
print(nic)
if not nic:
raise Exception("WiFi init fail")
nic.connect(WIFI_SSID, WIFI_PASS)
print("connected")
import urequests as request
headers ={
"User-Agent": "MaixPy"
}
draw_line('')
draw_line("HTTP Requesting...")
print(nic.ifconfig())
url = "http://maker.ifttt.com/trigger/event/with/key/key?value1=Nat&value2=StayX"
res = request.get(url, headers=headers)
draw_line("status code={}".format(str(res.status_code)))
```
ซึ่งโค๊ดด้านบนผมลองเขียน Request ไปที่ IFTTT แต่ว่า ผมไม่ระบุ Token จึงได้ status 401 กลับมานั่นคือ Not authorized นั่นเองครับ
โดย ณัฐ วีระวรรณ์
# การใช้งาน MQTT
หลังจากที่เรา [เริ่มต้น IoT กับ CorgiDude ด้วยการสร้าง HTTP Request ด้วย urequests.py ](https://www.aiiotshop.com/article/8/%E0%B9%80%E0%B8%A3%E0%B8%B4%E0%B9%88%E0%B8%A1%E0%B8%95%E0%B9%89%E0%B8%99-iot-%E0%B8%81%E0%B8%B1%E0%B8%9A-corgidude-%E0%B8%94%E0%B9%89%E0%B8%A7%E0%B8%A2%E0%B8%81%E0%B8%B2%E0%B8%A3%E0%B8%AA%E0%B8%A3%E0%B9%89%E0%B8%B2%E0%B8%87-http-request-%E0%B8%94%E0%B9%89%E0%B8%A7%E0%B8%A2-urequests-py)กันไปแล้ว คราวนี้มาถึงคิว MQTT โพรโตคอลยอดนิยมกันแล้วครับ!!
ใน CorgiDude มี chip ESP8285 อยู่ด้วย แต่ Firmware ข้างในเป็นรุ่น AT-Command แต่ว่าไม่ใช่ปัญหาแต่อย่างใด เนื่องจากทาง MaixPy Firmware เอง ได้ implement usocket มาให้เราแล้ว... เราจึงสามารถใช้งาน mqtt library ของ micropython ได้เลยครับ
เริ่มต้นด้วยการ ดาวน์โหลดไฟล์ umqtt.py กันก่อนได้ [โดยการคลิ๊กที่นี่](https://gist.github.com/NAzT/b564e5576e674defa3cfd0ebc08a7af8/archive/0c9ab95dc69a4d142c5882090be5e9b6fe07b7cf.zip)
หลังจากนั้นอัพโหลดไฟล์ umqtt.py เข้าไปเลยครับ
หลังจากนั้น ก็มาทดลอง publish และ subscribe กันได้เลยครับ!
```
import network, time
import time
from Maix import GPIO
from machine import UART
from fpioa_manager import fm, board_info
import lcd, image
from umqtt import MQTTClient
WIFI_SSID = "LiLy_2.4G"
WIFI_PASS = ""
counter = 1
line_height = 20
lcd.init(type=1, freq=15000000)
lcd.freq(16000000)
def draw_line(text, color=lcd.RED):
global counter
lcd.draw_string(0, line_height*counter, text, color, lcd.BLACK)
counter += 1
draw_line("CorgiDude!", lcd.YELLOW)
time.sleep(2)
draw_line("Setting up gpios", lcd.YELLOW)
fm.register(0, fm.fpioa.GPIOHS1, force=True)
wifi_io0_en=GPIO(GPIO.GPIOHS1, GPIO.OUT)
fm.register(8, fm.fpioa.GPIOHS0)
wifi_en=GPIO(GPIO.GPIOHS0,GPIO.OUT)
fm.register(board_info.WIFI_RX,fm.fpioa.UART2_TX)
fm.register(board_info.WIFI_TX,fm.fpioa.UART2_RX)
def wifi_enable(en):
global wifi_en
wifi_en.value(en)
draw_line("Preparing NIC...")
uart = UART(UART.UART2,115200,timeout=1000, read_buf_len=4096)
wifi_enable(0)
time.sleep_ms(200)
wifi_enable(1)
def wifi_reset():
global uart
print("wifi reset")
wifi_enable(0)
time.sleep_ms(200)
wifi_enable(1)
time.sleep(2)
uart = UART(UART.UART2,115200,timeout=1000, read_buf_len=1024)
tmp = uart.read()
uart.write("AT+UART_CUR=921600,8,1,0,0\r\n")
time.sleep_ms(200);
print(uart.read())
uart = UART(UART.UART2,921600,timeout=1000, read_buf_len=4096) # important! baudrate too low or read_buf_len too small will loose data
time.sleep_ms(200);
print(uart.read())
uart.write("AT\r\n")
tmp = uart.read()
print(tmp)
if tmp and not tmp.endswith("OK\r\n"):
print("reset fail")
return None
try:
nic = network.ESP8285(uart)
except Exception:
return None
return nic
nic = wifi_reset()
print(nic)
if not nic:
raise Exception("WiFi init fail")
nic.connect(WIFI_SSID, WIFI_PASS)
print("connected")
draw_line('')
print(nic.ifconfig())
def sub_cb(topic, msg):
print((topic, msg))
c = MQTTClient("umqtt_client", "test.mosquitto.org")
c.set_callback(sub_cb)
c.connect()
#c.disconnect()
c.subscribe(b"foo_topic")
count = 0
while True:
if True:
# Blocking wait for message
c.publish(b"foo_topic", b"hello {}".format(counter))
counter += 1
c.wait_msg()
else:
# Non-blocking wait for message
c.check_msg()
# Then need to sleep to avoid 100% CPU usage (in a real
# app other useful actions would be performed instead)
time.sleep(1)
c.disconnect()
```
จะเห็นว่า เราได้รับ message ของตัวเองผ่าน topic foo\_topic ได้แล้วครับ
ณัฐ วีระวรรณ์
# การใช้งาน Google Spreadsheet ผ่านทาง IFTTTT
เริ่มต้นด้วยการโหลด library ที่ชื่อว่า urequest.py มาเป็นตัวช่วยสำหรับการทำ HTTTP Request ให้ CorgiDude ของเราครับ ซึ่ง [คลิ๊กเพื่อโหลดได้ที่นี่เลย!](https://gist.github.com/NAzT/5821cacdb98d9eb28d30a597186e4be1/archive/bc072c17109a8be64e7885161516f778cf181464.zip)
เลือกไฟล์ > อัพโหลดไฟล์เข้าไปในบอร์ด > รอจนขึ้นว่า **save file OK**
IFTTT
หลังจากนั้น เรามาเริ่มด้วยการคลิ๊ก **Create** เพื่อเป็นการเริ่มสร้างโปรเจ็คใน IFTTT กัน ซึ่งเราะใช้ Webhook มารับ HTTP Request และ ใช้ Google Sheet เพื่อเก็บข้อมูลครับ
**มาเริ่มกันเลย!**
ขั้นตอนที่ 1 หลังจากคลิ๊กตรงคำว่า **This** ก็มาเลือก Webhook ครับ
ตั้งชื่อ event ว่าอะไรก็ได้ ในเคสนี้ผมตั้งว่า **spreadsheet** ครับ!
หลังจากนั้นคลิ๊กคำว่า **That** แล้วเชื่อม Service Sheet เข้ากับ Webhook ครับ
หลังจากนั้นก็มา Custom format โดยในภาพจะเห็นเป็น 3 คอลัมม์ นั่นก็คือ 3 Value นั่นเองครับ
เมื่อเรากด Create Action แล้วให้เราไปก๊อป IFTTT Token มาครับ ซึ่งสามารถไปหาได้จากลิ้งก์นี้เลยครับ
เข้าหน้า เพื่อไปกีอปปี้ Token มาเก็บไว้
หลังจากนั้น Copy Token มาใส่ในโปรแกรมของเรา โดยแก้ token, trigger และ query สำหรับการส่งข้อมูลเข้า Spreadsheet ของเราครับ
โหลดโค๊ดทั้งหมดได้ที่นี่เลย
```
from Maix import GPIO
from machine import UART
from fpioa_manager import fm, board_info
import lcd, image
import usocket, network, time
import urequests as request
fm.register(8, fm.fpioa.GPIOHS0)
wifi_en=GPIO(GPIO.GPIOHS0,GPIO.OUT)
fm.register(board_info.WIFI_RX,fm.fpioa.UART2_TX)
fm.register(board_info.WIFI_TX,fm.fpioa.UART2_RX)
counter = 1
line_height = 20
WIFI_SSID = "LiLy_2.4G"
WIFI_PASS = "@O53732i36"
lcd.init(type=1, freq=15000000)
lcd.freq(16000000)
def draw_line(text, color=lcd.RED):
global counter
lcd.draw_string(0, line_height*counter, text, color, lcd.BLACK)
counter += 1
def wifi_enable(en):
global wifi_en
wifi_en.value(en)
#draw_line("wifi_en({})".format(en))
def wifi_reset():
global uart
print("wifi reset")
wifi_enable(0)
time.sleep_ms(200)
wifi_enable(1)
time.sleep_ms(200)
uart = UART(UART.UART2,115200,timeout=1000, read_buf_len=1024)
tmp = uart.read()
time.sleep_ms(200);
print(uart.read())
uart.write("AT\r\n")
tmp = uart.read()
if tmp and not tmp.endswith("OK\r\n"):
draw_line("reset failed")
print("reset fail")
return None
try:
nic = network.ESP8285(uart)
#draw_line("NIC OK!", lcd.GREEN)
except Exception:
return None
return nic
draw_line("CorgiDude!", lcd.YELLOW)
time.sleep(2)
draw_line("Preparing NIC...")
nic = wifi_reset()
if not nic:
draw_line("WiFi init fail!")
raise Exception("WiFi init fail")
else:
draw_line("Connectin to WiFi...")
nic.connect(WIFI_SSID, WIFI_PASS)
ip,subnet,gateway,dns,b,mac,ssid = nic.ifconfig()
print("WiFi Connected. ip={}, gateway={}".format(ip,gateway))
draw_line("WiFi Connected.", lcd.GREEN)
draw_line("")
draw_line("ip={}, gateway={}".format(ip,gateway), lcd.YELLOW)
draw_line("mac={}, ssid={}".format(mac,ssid), lcd.YELLOW)
#print(nic.ifconfig())
headers ={
"User-Agent": "MaixPy"
}
token = "dXUumQ_B39s6MarHpq2d11"
trigger = "sheet1"
query = "value1=Nat&value2=StayX"
url = "http://maker.ifttt.com/trigger/{}/with/key/{}?{}".format(trigger, token, query)
draw_line("")
draw_line("HTTP Requesting...")
res = request.post(url, headers=headers)
print(res.content)
print(res.status_code)
if res.status_code == 200:
draw_line(str(res.status_code), lcd.GREEN)
else:
draw_line(str(res.status_code))
draw_line(res.content, lcd.YELLOW)
```
เมื่อเปิดดูใน Spreadsheet เราจะเห็นข้อมูลแบบนี้ (ซึ่งสามารถแก้ได้ตรง query ได้เลย)
ตอน Request ก็จะได้ข้อมูลแบบนี้ครับ
แล้วเจอกันในบทความหน้าครับ 😃
ณัฐ วีระวรรณ์
# การใช้งาน LINE Notify
**สำหรับบทความนี้ เราจะลองมาใช้ LINE notify จาก CorgiDude ด้วย** library Corgi85 กันนะครับ
ก่อนอื่นเพื่อนๆ จะต้องทำการอัพเกรดเฟิร์มแวร์ CorgiDude และโปรแกรม library Corgi85 ลงใน ESP 8285 ก่อน โดยสามารถดูรายละเอียดได้จาก จากนั้นเพื่อนๆก็ต้องสร้างตัว LINE bot ซึ่งจะเชื่อมต่อกับ LINE ID ของเรา โดยจะทำให้เราสามารถแจ้งเตือนในกลุ่มที่เราแอด bot เข้าไปด้วยได้ สามารถดูรายละเอียดเพิ่มได้ที่ (เมื่อทำการสร้างตัว LINE bot เรียบร้อยแล้ว เราจะต้องใช้ตัวรหัส token ในการใช้งาน) โดยวิธีการดังนี้\*\*
เปิดเว็ป ทำการสแกน QR Code เพิ่ม "LINE Notify" เป็นเพื่อน
**กด "เข้าสู่ระบบ" ใส่ E-mail และ password ของ LINE ที่เราลงทะเบียนไว้จากนั้นกด "LOGIN"**
**จากนั้นเปิด tap เลือก "My page"**
**กด "Generate token"**
**ตั้งชื่อให้ LINE bot และกลุ่มแชทที่ต้องการให้แจ้งเตือน โดยผมจะเลือกเป็น 1-no-1 เพื่อทำการทดสอบ** **\*\*กด "Generate token"\*\***
**เราจะได้รหัส token ที่ใช้ในการแจ้งเตือนให้กด Copy ไว้ เป็นการเสร็จเรียบร้อย**
**เมื่อเราได้รหัส** **\*\*token มาแล้วก็สามารถเอามาใช้ใน code micropython ที่ใช้ใน\*\*** **\*\*CorgiDude ได้เลย\*\* โดย ตัวอย่าง code เป็นแบบนี้ครับ (**[**รายละเอียดเพิ่มเติม LINK**](https://www.aiiotshop.com/b/2)**)**
```
import sensor, image, time, lcd
from Corgi85 import corgi85
token = "sqdSuyH9oidoRBZG5T72UdpYiMFcgeUEifAYTmSfdo8"
#reset esp8285
corgi85.reset()
#print(dir(corgi85))
#setup camera
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
#sensor.set_windowing((224, 224))
#sensor.set_vflip(1)
#sensor.set_hmirror(0)
sensor.run(1)
#setup LCD screen
lcd.init()
lcd.rotation(0)
time.sleep(1)
count = 0
while(corgi85.wifi_check() == 0):
print("WIFI Connecting")
time.sleep(1)
print("\n\nWIFI Connected")
print("\n\nSet line Token:",token)
corgi85.LINE_setToken(token) #set line Token
print("\n\nsend line image")
img = sensor.snapshot() # camera capture image
lcd.display(img) # lcd display image
corgi85.LINE_notifyPicture(img, "CorgiDude LINE notify Picture") # send image to line noti
time.sleep(3)
print("\n\nsend message to line noti: Hello From CorgiDude")
corgi85.LINE_notify("Hello From CorgiDude")
time.sleep(3)
print("\n\nsend line sticker")
corgi85.LINE_notifySticker(1, 1) # detail : https://devdocs.line.me/files/sticker_list.pdf
time.sleep(3)
print("\n\nsend line sticker & message")
corgi85.LINE_notifySticker_text("Hello From CorgiDude", 1, 1) #detail : https://devdocs.line.me/files/sticker_list.pdf
##print("\n\n",dir(corgi85))
## https://github.com/AiDude-io/CorgiDude/tree/master/08%20-%20Face%20Detection << download kmodel
#import sensor
#import image
#import lcd
#import KPU as kpu
#from Corgi85 import corgi85
#while(corgi85.wifi_check() == 0):
#print("WIFI Connecting")
#time.sleep(1)
#token = "sqdSuyH9oidoRBZG5T72UdpYiMFcgeUEifAYTmSfdo8"
#corgi85.LINE_setToken(token) #set line Token
#lcd.init()
#lcd.rotation(0)
#sensor.reset()
#sensor.set_pixformat(sensor.RGB565)
#sensor.set_framesize(sensor.QVGA)
#sensor.run(1)
#task = kpu.load(0x300000)
#anchor = (1.889, 2.5245, 2.9465, 3.94056, 3.99987, 5.3658, 5.155437, 6.92275, 6.718375, 9.01025)
#a = kpu.init_yolo2(task, 0.5, 0.3, 5, anchor)
#while(True):
#img = sensor.snapshot()
#faces = kpu.run_yolo2(task, img)
#if faces:
#for face in faces:
#img.draw_rectangle(face.rect(),color=(0,255,0),thickness=2)
#img = img.resize(240,240)
#lcd.display(img)
#if faces:
#img2 = sensor.snapshot()
#corgi85.LINE_notifyPicture(img2, "Detected some people")
#kpu.deinit(task)
```
**เท่านี้เพื่อนๆก็สามารถแจ้งเตือนผ่าน LINE ด้วย CorgiDude ได้แล้วครับ**
# การใช้งาน ThingSpeak
🌟 ยินดีต้อนรับผู้อ่านทุกท่าน วันนี้เราจะมาเพิ่มความสามารถให้กับ CorgiDude ด้วยการเก็บข้อมูลบน Cloud กันแบบฟรี ๆ 🎉 แต่มีข้อแม้ข้อมูลจะต้องเป็นตัวเลข เท่านั้น เหมาะสำหรับการเก็บข้อมูลในรูปแบบนับจำนวน นอกจากนี้ยังทราบได้ว่าข้อมูลถูกบันทึกไว้ช่วงเวลาใด ทำให้สะดวกมากก นั่นคือ ThingSpeak นั่นเอง
**📚 สมัครสมาชิก ThingSpeak**
ขั้นตอนแรก ให้ทำการสมัครสมาชิกให้เรียบร้อยกันก่อนโดยเข้าไปที่ลิงก์
ขั้นตอนถัดมาให้เรากรอกข้อมูล อีเมล, ประเทศ, ชื่อ-นามสกุล และคลิกปุ่ม Continue ระบบจะส่งลิงก์ยืนยันไปยังอีเมลที่เราใช้สมัคร ให้ทำการยืนยันให้เรียบร้อยก่อนการใช้งาน
**📚 สำหรับผู้ที่สมัครสมาชิก ThingSpeak เรียบร้อยแล้ว**
ให้ทำการล็อกอิน ThingSpeak ได้ที่ลิงก์ หลังจากเข้ามาแล้ว เราจะพบกับหน้า Channel ว่างเปล่า (หากยังไม่เคยสร้าง Channel มาก่อนหน้า) โดยให้เราคลิกปุ่ม New Channel
หลังจากนั้นเราจะพบกับหน้าแบบฟอร์มสร้าง Channel โดยในตัวอย่างภาพจะมี 2 ส่วนที่เป็นพื้นฐานตั้งค่า ซึ่งในส่วน A ให้เราทำการตั้งชื่อ Channel ที่เราจะใช้เก็บข้อมูล โดยในตัวอย่างตั้งชื่อว่า CorgiDude Channel และในส่วน B ให้เราติ๊กถูก Field ตามจำนวนที่ต้องการใช้งาน เช่น หากต้องการเก็บค่าอุณภูมิอากาศ ให้เก็บใน Field1 หากต้องการเก็บค่าความชื้นในอากาศให้แยกเก็บใน Field2 เป็นต้น
ในส่วนข้อมูลอื่น ๆ หากมีข้อมูลอยู่แล้วสามารถกรอกเพิ่มเติมได้เลย หลังจากกรอกข้อมูลเสร็จแล้ว ให้ทำการคลิกปุ่ม Save Channel
หลังจากสร้าง Channel เรียบร้อยแล้ว เราจะพบกับหน้าเว็บดังตัวอย่างภาพ เพียงเท่านี้ก็พร้อมให้ CorgiDude ส่งข้อมูลมายัง ThingSpeak ได้แล้ว 🎉
**📚 วิธีการดู ThingSpeak API Key เพื่อใช้ในการส่งข้อมูล**
คลิกเมนู API Keys จะพบกับหน้าดังภาพตัวอย่าง ซึ่งในส่วน Write และ Read จะมี API Key แตกต่างกันเหมาะสำหรับไว้ใช้ในการนำไปเขียนโปรแกรมเพื่อเช็คสิทธิ์ในการ อ่าน / เขียน นั่นเอง
**📚 ตัวอย่าง Source Code การตรวจจับใบหน้าคนด้วยบอร์ด CorgiDude และส่งข้อมูลไปยัง ThingSpeak**
**หมายเหตุ :** ให้ทำการอัพเดท Firmware CorgiDude เป็น Version ล่าสุด และตั้งค่าการเชื่อมต่อ WiFi ให้เรียบร้อย ซึ่งสามารถทำตามบทความได้จากลิงก์
[](http://www.youtube.com/watch?v=8PCeLBL6Hvg)
```
import sensor
import image
import lcd
import KPU as kpu
from Corgi85 import corgi85
import random
while(corgi85.wifi_check() == 0):
print("WIFI Connecting")
time.sleep(1)
corgi85.Thingspeak_init()
corgi85.Thingspeak_accountSetup("_____WRITE_KEY_____", "_____CHANNEL_ID_____")
lcd.init()
lcd.rotation(0)
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.run(1)
task = kpu.load(0x300000)
anchor = (1.889, 2.5245, 2.9465, 3.94056, 3.99987, 5.3658, 5.155437, 6.92275, 6.718375, 9.01025)
a = kpu.init_yolo2(task, 0.5, 0.3, 5, anchor)
while(True):
img = sensor.snapshot()
faces = kpu.run_yolo2(task, img)
if faces:
for face in faces:
img.draw_rectangle(face.rect(),color=(0,255,0),thickness=2)
img = img.resize(240,240)
lcd.display(img)
if faces:
corgi85.Thingspeak_writeField(3, 100)
print("Person Detect!")
else:
corgi85.Thingspeak_writeField(3, 0)
kpu.deinit(task)
```
micropython ที่ใช้ใน CorgiDude ได้เลย โดย ตัวอย่าง code เป็นแบบนี้ครับ ([รายละเอียดเพิ่มเติม LINK](https://www.aiiotshop.com/b/2))
# การใช้งาน Google Vision
**🌟 ภาพตัวอย่างการใช้ Google Vision อ่านป้ายทะเบียนรถ**
😲 **ผลลัพธ์ที่ได้จาก Google Vision**
จากภาพตัวอย่าง ในส่วนเรื่องความแม่นยำจะเห็นว่า ตัวอักษร 'ง' ถูกสะกดเป็น 'ม' จะไม่แม่นยำ 100% แต่ทั้งนี้ความแม่นยำจะขึ้นอยู่กับ font ที่เลือกใช้ หรือความชัดของรูปภาพด้วยนั่นเอง ทั้งนี้เราอาจจะเก็บทั้งรูปภาพ และให้ Google Vision แกะตัวอักษรควบคู่ก็ได้เช่นกัน เพื่อใช้ตรวจสอบภายหลัง
ก่อนอื่นเรามาทำความรู้จักกับ **Google Vision** เบื้องต้นกันเถอะ Google Vision เป็นบริการจากทาง Google ที่มี API ให้ใช้งานทางด้าน **Machine Learning (ML)** โดยจะมีทั้งเอกสาร และโค้ดตัวอย่างของภาษาโปรแกรมมิ่ง เช่น **C#, GO, Java, Node.js, PHP, Python, Ruby** เรียกได้ว่า Google ยกตัวอย่างภาษาโปรแกรมมิ่งยอดนิยมมาให้ใช้กันเลยทีเดียว
ในบทความนี้เราจะใช้หนึ่งในบริการจาก Google Vision นั้นก็คือ **Optical Character Recognition (OCR)** หรือที่เรารู้จักกัน คือการแกะตัวอักษรจากรูปภาพ หากต้องการทราบความสามารถ Google Vision ทั้งหมด แน่นอนว่ามีฟีเจอร์อีกมากมายที่บทความนี้ไม่ได้พูดถึง ให้เข้าไปดูรายละเอียดได้ที่ลิงก์ ****
**🌟 ภาษาโปรแกรมมิ่งที่ใช้ทดสอบการใช้งาน Google Vision** ในตัวอย่างบทความเราจะเลือกใช้ **Node.js** และเรียก **REST API** เพื่อใช้งาน **OCR** มาแกะตัวอักษรป้ายทะเบียนรถ
🌟 **ขั้นตอนการทำงานของโปรแกรม**
\*\*📌 Step 1 \*\*Line Messaging API ใช้เพื่อส่งรูปภาพจากแชทไลน์ ไปประมวลผลบน Server
วิธีการตั้งค่าการใช้งาน Line Messaging API มีบทความในอินเทอร์เน็ตค่อนข้างเยอะเลยทีเดียว เช่น
[**13 สัญญาณจาก Webhook Events ที่จะปลุกให้ LINE Bot ของคุณตื่นจากภวังค์**](https://medium.com/linedevth/12-%E0%B8%AA%E0%B8%B1%E0%B8%8D%E0%B8%8D%E0%B8%B2%E0%B8%93%E0%B8%88%E0%B8%B2%E0%B8%81-webhook-events-%E0%B8%97%E0%B8%B5%E0%B9%88%E0%B8%88%E0%B8%B0%E0%B8%9B%E0%B8%A5%E0%B8%B8%E0%B8%81%E0%B9%83%E0%B8%AB%E0%B9%89-line-bot-%E0%B8%82%E0%B8%AD%E0%B8%87%E0%B8%84%E0%B8%B8%E0%B8%93%E0%B8%95%E0%B8%B7%E0%B9%88%E0%B8%99%E0%B8%88%E0%B8%B2%E0%B8%81%E0%B8%A0%E0%B8%A7%E0%B8%B1%E0%B8%87%E0%B8%84%E0%B9%8C-4cb7da653274)
**\[Chat Bot ง่ายๆ ด้วย Line Messaging API !!** [**PHP, NodeJS, Heroku\] แบบ Step by step**](https://medium.com/@benz20003/chat-bot-%E0%B8%87%E0%B9%88%E0%B8%B2%E0%B8%A2%E0%B9%86-%E0%B8%94%E0%B9%89%E0%B8%A7%E0%B8%A2-line-messaging-api-php-nodejs-heroku-%E0%B9%81%E0%B8%9A%E0%B8%9A-step-by-step-943322819854)
**📌 Step 2** Node.js ใช้เพื่อการประมวลผล Webhook (Line Messaging API)
Source Code : [**https://github.com/Gr4vity4/Google-Vision-OCR**](https://github.com/Gr4vity4/Google-Vision-OCR)
**📌 Step 3** Google Vision ใช้ฟีเจอร์ OCR เพื่ออ่านป้ายทะเบียนรถ โดยประมวลผลที่รับมาจาก Node.js และส่งผลลัพธ์กลับ
หมายเหตุ : ให้ทำการสร้าง Credential ในส่วน API Key ให้เรียบร้อยก่อน เพื่อที่เราจะนำ Key ที่ได้ไปใช้งานภายใน REST API
และตรวจสอบการเปิดใช้งาน Library **Cloud Vision API**
# Modules
# Button Switch
โมดูลสวิตช์ปุ่มกดพร้อมตัวต้านทาง Pull down พร้อมต่อกับ CorgiDude ได้ทันที พร้อมไฟ LED แสดงสถานะ ทุกปุ่มกด
เนื้อหาตัวอย่างการใช้งาน [รายละเอียดเพิ่มเติม](https://app.gitbook.com/s/-MS7gWqq4Dqux5LfP3Uf/advance/gpio/document_1)
:pushpin: ช่องทางการสั่งซื้อโมดูล โมดูลสวิตช์ 5 ปุ่มกด Button Switch [สั่งซื้อโมดูล](https://www.aiiotshop.com/p/64)
# Drive Motor
โมดูลขับมอเตอร์ 2 ช่อง แต่ละช่องสามารถขับเอาต์พุตได้ถึง 3A , กระแสช่วงพีคสูงสุด 5A ระหว่างที่อยู่ในโหมดสแตนบาย ใช้กระแสเพียง 2uA รอบรับไฟได้ช่วงกว้าง 3-15V สัญญาณควบคุมอินพุตระหว่าง 2.2-6V
:pushpin: ช่องทางการสั่งซื้อโมดูล โมดูลสวิตช์ 5 ปุ่มกด Button Switch [สั่งซื้อโมดูล](https://www.aiiotshop.com/p/66)
# GPIO Input
โมดูล GPIO Input เหมาะสำหรับบอร์ด CorgiDude รับอินพุตได้ถึง 5 ขาใช้งาน
:pushpin: ช่องทางการสั่งซื้อโมดูล โมดูลสวิตช์ 5 ปุ่มกด Button Switch [สั่งซื้อโมดูล](https://www.aiiotshop.com/p/68)
# Servo Motor
โมดูลสำหรับต่อ Servo Motor และ GPIO Output\ สามารถต่อ Servo Motor ได้ถึง 4 ตัว และยังมี GPIO Output ถึง 4 ขาใช้งาน และต่อกับ CorgiDude บอร์ดได้เลย
:pushpin: ช่องทางการสั่งซื้อโมดูล โมดูลสวิตช์ 5 ปุ่มกด Button Switch [สั่งซื้อโมดูล](https://www.aiiotshop.com/p/67)
# Demo Projects
# Face Recognition
# ตอนที่ 1
มาทำระบบจดจำใบหน้า พร้อมส่งข้อมูลเข้า Google Sheet เพื่อทำระบบลงเวลา ด้วยบอร์ด CorgiDude กัน โดยตอนนี้จะเป็น ทฤษฏีแบบคร่าว ๆ นะครับปูพื้นฐานสำหรับคนที่ไม่เคยรู้มาก่อนว่ามันทำยังไงก่อนที่จะเริ่มเขียนโปรแกรม
หัวใจสำคัญของ Face Recognition ก็คือตัว Face Encoder (หรือจะเรียน face embedding / feature extractor ก็แล้วแต่) หน้าที่ของมันคือ จะแปลงภาพใบหน้าให้ออกมาเป็นตัวเลขจำนวนหนึ่ง (ใน CorgiDude เป็นเลขทศนิยม 128 ตัว) ความพิเศษของโมเดลนี้คือ ถ้าเราเอาภาพใบหน้าที่คล้าย ๆ กันเข้าไปมันจะได้เลขชุดที่คล้าย ๆ กันออกมา เราจึงสามารถเอาเลขชุดนี้ไปเปรียบเทียบกับฐานข้อมูลเลขใบหน้าแต่ละคนที่เราเก็บไว้ เพื่อหาว่ามันคล้ายกับเลขไหนมากที่สุด แล้วทายว่าเป็นคนนั้นออกมา รายละเอียดจะเป็นยังไง ดูใน Video นี้ได้เลยครับ
{% embed url="" %}
# ตอนที่ 2
หลังจากที่ตอนแรกได้พูดถึงทฏษฏีกันไปบ้างแล้ว ในตอนนี้ก็จะเป็นการ Setup ตัวบอร์ด ใส่โมเดล และเชื่อมต่อบริการ IFTTT เพื่อให้สามารถเก็บข้อมูลใบหน้าที่จับได้ลงไปใน Google Sheet วิธีการก็ไม่ยาก สามารถทำตามใน Video และบทความนี้ได้เลย
1. การ Flash ESP8285 เพื่อใช้งาน IoT
2. โหลดโค้ดและโมเดลรู้จำใบหน้าได้ที่นี่
3. เชื่อมต่อบริการ IFTTT ที่เว็บไซต์ ifttt.com อ่านเนื้อหาตอนแรก [https://www.facebook.com/comdet/videos/4783580461659470](https://www.facebook.com/comdet/videos/4783580461659470/)
{% embed url="" %}
# ตอนที่ 3
ใน ep นี้เราจะมาทดสอบแล้วก็รันโค้ดกัน บอร์ดที่ลงโมเดลและลงโค้ด (บันทึกให้รันอัตโนมัติไว้แล้ว) จะทำการจับภาพใบหน้าและส่งไปยัง FaceEncoder เพื่อทำการจำแนกใบหน้าออกมา และนำ ID ใบหน้าที่ได้ส่งเข้าไปใน Google Sheet ผ่าน IFTTT ตามที่เราได้ตั้งค่าไว้ Log ที่ได้ผมได้เขียน Script เพื่อให้สามารถดึงข้อมูลวันที่และ ID ออกมาเป็นระบบลงเวลาอย่างง่าย ๆ ถ้ามีใบหน้าปรากฏในช่วงเวลาที่กำหนดจะแสดงเลข 1 ออกมา สามารถนำไปประยุกต์ใช้งานต่อได้ตามสะดวกเลยครับ เดี๋ยว EP หน้าจะอธิบายโค้ดและ วิธีแก้ไขพารามิเตอร์ต่าง ๆ กัน
\=> \[\[google sheet การเอา log ไปใช้งาน]] (ให้ทำการก๊อปปี้ไปใช้ เข้าไปที่เมนู ไฟล์ -> ทำสำเนา) :
\=> \[\[โค้ด Download ได้จาก]] :
{% embed url="" %}
# ตอนที่ 4
สวัสดีครับ หากหลาย ๆ ท่านได้อ่านบทความในร้านที่ผ่าน ๆ มา จะสังเกตุได้ว่ามีการใช้งานโมเดลในตรวจหาวัตถุ ไม่ว่าจะเป็น สิ่งของ รถ ใบหน้า หรือแม้แต่การใส่หน้ากากอนามัย ซึ่งส่วนใหญ่จะใช้โมเดล AI ที่มีชื่อว่า Yolo ในทุกบทความจะมีการใช้โมเดลสำเร็จรูปพร้อมโค้ดให้รัน แต่ถ้าเกิดว่าเราอยากจะสอนโมเดลเองเพื่อดูความแม่นยำ หรือปรับปรุงคุณภาพการจำแนก หรือแม้แต่ปรับโครงสร้างโมเดลจะทำยังไง เดี๋ยวในบทความนี้เราจะมาลองทำกันดูครับ
ในการสอนโมเดลทางเราจะเลือกใช้ Library มีชื่อว่า aXeleRate เป็นชุดโปรแกรมสำเร็จรูปที่ใช้งานง่าย แต่มีประสิทธิภาพ ทุกคนสามารถทำตามได้ โดย AIWintermuteAI เป็นผู้ทำขึ้นมาและเป็น opensource นั่นหมายความว่าเราสามารถเข้าไปดูวิธีการทำงานภายในโค้ดได้เลยครับ
ในการสอนโมเดลปกติเราจะใช้เครื่องที่มีการ์ดจอในการประมวลผลที่สูง ซึ่งมีราคาแพง บางครั้งในการใช้งานที่ไม่ได้สอนโมเดลหรือรันงานตลอด อาจจะไม่จำเป็นหรือใช้งานได้อย่างไม่คุ้มค่า ดังนั้น Google จึงมีเครื่องมือที่เรียกว่า Colab ในการให้เราเขียนโค้ด python เพื่อใช้งานการ์ดจอที่อยู่บนเซิฟเวอร์ได้แบบฟรี ๆ ถ้ารันคำสั่งทิ้งไว้ไม่เกิน 12 ชั่วโมง (ซึ่งในการทำครั้งนี้ก็ไม่เกินอยู่แล้ว) เราจึงเลือกใช้บริการนี้ครับ โดยโค้ดจะจัดไว้เป็นกลุ่มสามารถกดเพื่อรันคำสั่งได้เลย
รายละเอียดโค้ดในการสอนโมเดล :
ใน colab นี้มี - การโหลด Dataset ของใบหน้าที่ใส่ Mask ประมาณ 8000 รูป สามารถโหลดไปใช้ในงานอื่นได้ - เมื่อรันทุกอย่างถูกต้องโค้ดจะทำการสร้างไฟล์ kmodel เพื่อใช้ในบอร์ด CorgiDude ให้เอง
ต่อไปมาดูการรันแต่ละคำสั่ง ใน colab ครับ หลังจากที่ได้เข้า colab ไปแล้ว
สคริปนี้ เป็นการเรียก ใช้ lib - กำหนดให้ใช้ tensorflow v1 - กำหนดให้ใช้ imgaug v0.4 - git clone lib ของ aXeleRate - ทำการต่อ path library ที่โหลดไปใว้ในไฟล์ระบบ - ดึงคำสั่งที่เกี่ยวข้องในการรันเข้ามาใช้งาน
สคริปนี้ - โหลด detasets - ทดสอบแสดงผล datasets
สคริปนี้ เป็นการย้าย datasets เอาใว้ใช้ valid 20% ของ datasets ทั้งหมด
ส่วนนี้เป็นการกำหนด config ในการเทรนโมเดล ซึ่งมีส่วนที่สำคัญดังนี้ - type เป็นชนิด จะเปลียนได้ 3 แบบ Classifier Detector SegNet (จำแนกภาพ, ตรวจจับ(แบบสีเหลี่ยม),ตรวจจับแบ่งขอบเขตวัตถุ) - architecture เป็นโครงสร้างของโมเดล มีให้เลือกตามนี้ครับ (ถ้าเป็น CorgiDude แนะนำให้ใช้ MobileNet ครับ)
\- input\_size ก็จะเป็นขนาดของรูปที่เราต้องการนำเข้าไปสอน ถ้าเป็น MobileNet ก็จะมี 224,160,128 ประมาณนี้ครับ - anchors คือค่ากรอบสี่เหลี่ยมที่จะเกิดขึ้นตอนตรวจจับได้ ถ้าไม่รู้จะใส่อะไรให้คงค่าเดิมไว้ แต่ถ้าใครอยากเปลียนให้ลองอ่านรายละเอียดเพิ่มเติมที่ link ในโค้ดครับ) - labels ปกติข้อมูลที่ออกมาจาก dataset จะเป็นตัวเลข ค่านี้จะเป็นตัวจับคู่ระหว่างตัวเลขและชื่อที่เราสามารถอ่านได้ - full ค่าตรงนี้เป็นการบอกให้โมเดลไปโหลดข้อมูล weight จากโมเดลอื่น (ที่สอนมาดีแล้ว) มาใส่ (จะทำให้การสอนทำได้ไวขึ้น) ถ้าไม่มีจะสุ่มขึ้นมาใหม่ - actual\_epoch เทรนจำนวนกี่รอบ - train\_image\_folder ที่อยู่รูปที่เราจะเอาใว้เทรน - train\_annot\_folder ที่อยู่เฉลยที่เราจะเอาใว้เทรน - valid\_image\_folder ที่อยู่รูปที่เราจะเอาใว้ทดสอบ - valid\_annot\_folder ที่อยู่เฉลยที่เราจะเอาใว้ทดสอบ - batch\_size ในการสอนภาพจะถูกโหลดเข้าไปในการ์ดจอ จำนวนนี้บอกว่าจะเอากี่รูป ถ้าคุณมีแรมเยอะสามารถใส่เยอะและทำให้สอนได้เร็วขึ้น - learning\_rate คืออัตราการเรียนรู้ ถ้ามีค่ามากโมเดลจะเก่งเร็ว แต่ผลลัพท์จะแกว่งไปมา ถ้าค่าน้อยจะตรงกันข้าม - saved\_folder คือ ที่อยู่ในการบันทึกไฟล์ h5 และ kmodel - first\_trainable\_layer layer ไหนที่จะเริ่มเทรน ถ้าไม่ใส่คือเทรนหมด - type บันทึกไฟล์อะไรบ้าง
โค้ดด้านบนนี้ ทดสอบดูว่าเครื่องที่เรารันโค้ดอยู่มีการ์ดจอเชื่อมต่อหรือไม่
โค้ดส่วนนี้เป็นต้นไปโปรแกรมจะเริ่มสอนโมเดลให้ตรวจจับตามข้อมูลที่เราสอนให้มัน และจะทำการบันทึกรอบที่มันสามารถตรวจจับได้ดีที่สุดลงไปเรื่อยๆ จนกว่าจะเทรนครบจำนวนที่เราตั้งใว้ พอรันจบ โปรแกรมจะเอาไฟล์ที่ดีที่สุดมาแปลงเป็น kmodel เพื่อให้เราสามารถใช้งานได้ต่อไปครับ
โค้ดส่วนนี้ ใช้สำหรับทดสอบรูปดูว่าได้ผลลัพธ์ตรงหรือไม่
โมเดลในบทความสอนเสร็จเรียบร้อยสามารถดาวน์โหลดได้จาก : (เผื่อไม่อยากรันโค้ดเอง)
สำหรับโค้ดที่ใช้รันใน CorgiDude สามารถดาวน์โหลดได้จาก :
สำหรับการ flash kmodel สามารถตามอ่านต่อที่บทความนี้ได้เลยครับ
# Image Classification
# CorgiDude บอร์ด Image Classification โดยใช้ MobileNetV1
ดีครับ สำหรับบอร์ด CorgiDude ที่อยากจะทำ Image Clssification นั้นนะครับ บทความนี้จะมาสอนใช้โมเดลที่มีอยู่แล้วนะครับ แต่ถ้าอยากจะเทรนเองเดียวมีบทความต่อให้นะครับ เรามาเริ่มกันเลยดีกว่าครับ ก่อนอื่นก็ต้องมี โมเดลก่อนครับ ลิ้งโหลดด้านล่างครับ
(]
ต่อไปก็ทำการ Flash model ที่ได้โหลดมาครับ หรื่อใคร Flash model ไม่เป็น ไปทำตามบทความตามลิ้งต่อไปนี้ครับ
(]
Flash ไปที่ตำแหน่ง 0x200000 เลยครับ
หลังจาก Flash เสร็จแล้ว ต่อไปนำไฟล์ labels.txt ไปใว้ใน SD Card ได้เลยครับ ไฟล์ labels.txt หาได้จาก
(]
นำไฟล์ labels.txt ไปใส่ SD Card ได้เลยครับ เรามารัน script ต่อไปนี้ได้เลยครับ
```python
import sensor, image, lcd, time
import KPU as kpu
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.set_windowing((224, 224))
sensor.set_vflip(1)
sensor.run(1)
lcd.init(type=2, freq=20000000, color=lcd.BLACK)
lcd.rotation(2)
f=open('/sd/labels.txt','r')
labels=f.readlines()
f.close()
task = kpu.load(0x200000)
clock = time.clock()
while(True):
img = sensor.snapshot()
clock.tick()
fmap = kpu.forward(task, img)
fps=clock.fps()
plist=fmap[:]
pmax=max(plist)
max_index=plist.index(pmax)
a = lcd.display(img)
lcd.draw_string(0, 0, "%.2f:%s "%(pmax, labels[max_index].strip()))
print(fps)
a = kpu.deinit(task)
```
สำหรับใครที่ Copy Script แล้วมีปัญหา โหลดได้ครับ
(]
ผลจากการรันดูครับ
# CorgiDude บอร์ด Image Classification โดยใช้ Transfer Learning MobileNetV1
ดีครับ วันนี้ผมจะมาสอนใช้เครื่องมือที่จะทำ transfer learning MobilenetV1 โปรแกรมทั้งหมดผมไม่ได้เขียนเองนะครับ ผมแค่เห็นก่อน และใช้งานเป็นครับ ก่อนอืนเลย ผมจะมาอภิบาย transfer learning ที่ผมเข้าใจ แต่อาจจะถูกไม่ถูกไม่รู้นะครับแต่ผมอภิบายตามที่ผมเข้าใจครับ ถ้าผิดก็กราบขออภัยมา ณ ที่นี้ด้วยครับ
transfer learning คือการเอา โมเดลที่มีน้ำหนักคะแนนแล้วมาใช้ แต่เราไม่ได้ใช้ทั้งหมดนะครับ เราใช้ความเก่งของโมเดลที่สามารถแยกแยะ ได้ มากกว่าที่เราจะใช้ เช่น ผมใช้โมเดล MobilenetV1 เจ้าตัวนี้มีสามารถแยกแยะได้ 1000 อย่าง แต่ผมจะเอามา transfer learning ใหม่ใช้มันแยกแยะได้ 2 อย่างครับ คำถามคือมันต้องทำยังไงละถึงจะทำ transfer learning ได้ คำตอมคือ เราต้องไปแก้โมเดลบ่างส่วนแถวๆ สุดท้าย อะครับ แต่ข้างบนเราก็ยังใช้ของ โมเดล MobilenetV1 อยู่นัครับ
แล้วมันดีกว่าเทรนใหม่หมดยังไง - อันดับแรกมันทำให้เทรนได้ใวกว่า หลายเท่า - เทรนแล้วเก่งใวกว่า เพราะโมเดลเคยเรียนสิ่งที่อย่างกว่ามาแล้ว - ดาด้าเช็ตน้องก็ยังใช้งานได้อยู่ครับ
ส่วนตัวอย่างของผม ผมจะทำ แยกแยะได้ 2 อย่าง ครับ เป็นหมากับแมว อย่างละ 1000 รูป ครับ ลิ้งล่างนี้เลยครับ
(]
เราจะมาเริ่มกันได้เลยครับ ผมเลือกสิ่งที่ใช้งานง่ายมาให้แล้วครับ เข้าลิ่งนี้ครับ
(]
ลิ้งนี้จะพอไป colab ตามรูปครับ
หลังจากเข้ามาแล้ว กด Runtime---> Change runtime type
เลือกเป็น GPU ครับ
กด SAVE เลยครับ ต่อไปกด Connect
รอแปปหนึ่งครับ
หลังจากได้แบบนี้แล้ว กด Run cell ไปเลยครับ
คำสั่งนี้จะ กำหนดให้ใช้ tensorflow\_version 1.x และทำการ clone สิ่งที่ตเองต้องใช้มาครับ ต่อไป แก้ให้เป็นตามรูปครับ
!gdown #dog breed classification dataset !unzip --qq /content/datasets.zip from axelerate.networks.classifier.data\_gen import visualize\_dataset visualize\_dataset('datasets', 10)
แล้วกดรันเลยครับ ต่อไปแก้ config ตามนี้ครับ ตัวนี้พิมเอานะครับอันนี้ครับ
```python
{
"model" : {
"type": "Classifier",
"architecture": "MobileNet7_5",
"input_size": 224,
"fully-connected": [100,50],
"labels": [],
"dropout" : 0.2
},
"weights" : {
"full": "",
"backend": "imagenet",
"save_bottleneck": false
},
"train" : {
"actual_epoch": 10,
"train_image_folder": "/content/datasets",
"train_times": 4,
"valid_image_folder": "/content/datasets",
"valid_times": 4,
"valid_metric": "val_accuracy",
"batch_size": 32,
"learning_rate": 1e-4,
"saved_folder": "classifier",
"first_trainable_layer": "dense_1",
"augumentation": True
},
"converter" : {
"type": ["k210","tflite"]
}
}
```
หลังจากแก้เสร็จเราก็จะมาเริ่มเทรนกันเลยนะครับ
กดรันตามรูปเลยครับ ผลก็จะได้ประมาณนี้ครับ
รอจนกว่าจะเสร็จครับ เพราะทำเยอะ ทั้งเทรนและแปลงเป็น kmodel ให้ด้วยครับ ถ้าเสร็จแล้วจะเป็นแบบนี้ครับ
หลังจากที่เสร็จ ไฟล์ kmodel จะอยู่ตามรูปครับโหลดไปใช้งานได้เลยครับ
หลังจากโหลดมาแล้ว เอาไป Flash ไปที่ตำแหน่ง 0x200000 เลยครับ
วิธีการ Flash บทความนี้ครับ (]
โปรแกรมรันตามนี้เลยครับหลังจาก Flash เสร็จครับ
```
import sensor, image, lcd, time
import KPU as kpu
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.set_windowing((224, 224))
sensor.set_vflip(1)
lcd.init(type=2, freq=20000000, color=lcd.BLACK)
lcd.rotation(2)
labels=['cats','dogs'] #number of labels should match the number of labels the model was trained with
task = kpu.load(0x200000) #change to "/sd/name_of_the_model_file.kmodel" if loading from SD card
kpu.set_outputs(task, 0, 1, 1, 2) #the actual shape needs to match the last layer shape of your model
while(True):
kpu.memtest()
img = sensor.snapshot() #img = img.rotation_corr(z_rotation=90.0) uncomment if need rotation correction - only present in full maixpy firmware #a = img.pix_to_ai()
fmap = kpu.forward(task, img)
plist=fmap[:]
pmax=max(plist)
max_index=plist.index(pmax)
a = img.draw_string(0,0, str(labels[max_index].strip()), color=(255,0,0), scale=2)
a = img.draw_string(0,20, str(pmax), color=(255,0,0), scale=2)
print((pmax, labels[max_index].strip()))
a = lcd.display(img)
a = kpu.deinit(task)
```
ผลจากการทดลอง ตามรูปเลยครับ
# Object Detection
# CorgiDude บอร์ดกับการทำ Object Detection โดยใช้ Yolo
ดีครับ สำหรับบอร์ด CorgiDude ที่อยากจะทำ Object Detection นั้นนะครับ บทความนี้จะมาสอนใช้โมเดลที่มีอยู่แล้วนะครับ แต่ถ้าอยากจะเทรนเองเดียวมีบทความต่อให้นะครับ เรามาเริ่มกันเลยดีกว่าครับ Object Detection คือ การหาวัตถุ บนภาพ เช่า ตรวจจับใบหน้า ตรวจจับหน้าแมว ตรวจจับลูกบอล ตัวอย่างของผมเป็นตัวอย่าง yolov2 20class ตรวจจับได้ 20 อย่างเลย
classes = \['aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor']
ก่อนอื่นก็ต้องมี โมเดลก่อนครับ ลิ้งโหลดด้านล่างครับ (] ต่อไปก็ทำการ Flash model ที่ได้โหลดมาครับ หรื่อใคร Flash model ไม่เป็น ไปทำตามบทความตามลิ้งต่อไปนี้ครับ (] Flash ไปที่ตำแหน่ง 0x500000 เลยครับ
ต่อไปมาลอง Script ดูครับ
```python
import sensor,image,lcd,time
import KPU as kpu
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.set_vflip(1)
sensor.run(1)
lcd.init(type=2, freq=20000000, color=lcd.BLACK)
lcd.rotation(2)
clock = time.clock()
classes = ['aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor']
task = kpu.load(0x500000)
anchor = (1.08, 1.19, 3.42, 4.41, 6.63, 11.38, 9.42, 5.11, 16.62, 10.52)
a = kpu.init_yolo2(task, 0.5, 0.3, 5, anchor)
while(True):
clock.tick()
img = sensor.snapshot()
code = kpu.run_yolo2(task, img)
print(clock.fps())
if code:
for i in code:
a=img.draw_rectangle(i.rect())
a = lcd.display(img)
for i in code:
lcd.draw_string(i.x(), i.y(), classes[i.classid()], lcd.RED, lcd.WHITE)
lcd.draw_string(i.x(), i.y()+12, '%.3f'%i.value(), lcd.RED, lcd.WHITE)
else:
a = lcd.display(img)
a = kpu.deinit(task)
```
สำหรับใครที่ Copy Script แล้วมีปัญหา โหลดได้ครับ
(]
ผลการทดลอง
# CorgiDude บอร์ด ตรวจจับใบหน้าด้วย Yolo Face Detection
ดีครับ สำหรับบอร์ด CorgiDude ที่อยากจะทำ Face detection นั้น ครับ บทความนี้จะมาสอนใช้โมเดลที่มีอยู่แล้วนะครับ Face detection คือ การหาหน้าในรูปภาพ จะได้ตำแหน่งของหน้า ตามจำนวนหน้าเลยครับ เรามาเริ่มกันเลยดีกว่าครับ ก่อนอื่นก็ต้องมี โมเดลก่อนครับ ลิ้งโหลดด้านล่างครับ
(]
ต่อไปก็ทำการ Flash model ที่ได้โหลดมาครับ หรื่อใคร Flash model ไม่เป็น ไปทำตามบทความตามลิ้งต่อไปนี้ครับ
(]
Flash ไปที่ตำแหน่ง 0x300000 เลยครับ
ต่อไปมาลอง Script ดูครับ
```python
import sensor
import image
import lcd
import KPU as kpu
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.run(1)
lcd.init(type=2, freq=20000000, color=lcd.BLACK)
task = kpu.load(0x300000)
anchor = (1.889, 2.5245, 2.9465, 3.94056, 3.99987, 5.3658, 5.155437, 6.92275, 6.718375, 9.01025)
a = kpu.init_yolo2(task, 0.5, 0.3, 5, anchor)
while(True):
img = sensor.snapshot()
code = kpu.run_yolo2(task, img)
if code:
for i in code:
print(i)
a = img.draw_rectangle(i.rect(),color=(255,0,0),thickness=2)
a = lcd.display(img)
a = kpu.deinit(task)
```
สำหรับใครที่ Copy Script แล้วมีปัญหา โหลดได้ครับ
(]
ผลจากการทดลอง
# CorgiDude บอร์ดกับการทำ Cat Face Detection โดยใช้ Yolo2
ดีครับ สำหรับบอร์ด CorgiDude ที่อยากจะทำ Cat Face Detection นั้น ครับ บทความนี้จะมาสอนใช้โมเดลที่มีอยู่แล้วนะครับ Cat Face Detection คือ การหาหน้าในรูปภาพ จะได้ตำแหน่งของหน้าแมว ตามจำนวนหน้าเลยครับ เรามาเริ่มกันเลยดีกว่าครับ ก่อนอื่นก็ต้องมี โมเดลก่อนครับ ลิ้งโหลดด้านล่างครับ
(]
ต่อไปก็ทำการ Flash model ที่ได้โหลดมาครับ หรื่อใคร Flash model ไม่เป็น ไปทำตามบทความตามลิ้งต่อไปนี้ครับ
(]
Flash ไปที่ตำแหน่ง 0x400000 เลยครับ
ต่อไปมาลอง Script ดูครับ
```python
import sensor,image,lcd,time
import KPU as kpu
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.set_windowing((224, 224))
sensor.set_vflip(1)
sensor.run(1)
lcd.init(type=2, freq=20000000, color=lcd.BLACK)
lcd.rotation(2)
clock = time.clock()
classes = ['face','eye']
task = kpu.load(0x400000)
a = kpu.set_outputs(task, 0, 7,7,35)
anchor = (0.57273, 0.677385, 1.87446, 2.06253, 3.33843, 5.47434, 7.88282, 3.52778, 9.77052, 9.16828)
a = kpu.init_yolo2(task, 0.5, 0.3, 5, anchor)
while(True):
img = sensor.snapshot()
#a= img.resize(224,224)
a = img.pix_to_ai()
code = kpu.run_yolo2(task, img)
if code:
for i in code:
a=img.draw_rectangle(i.rect(),color = (0, 255, 0),thickness=4)
a = lcd.display(img)
a = kpu.deinit(task)
```
มาดูผลการทดลองดูครับ
# การทำ Dataset แบบ Object Detection ชนิด VOC ที่สามารถเอาไปใช้ตอนเทรนใน Yolo2 ได้เลย
สวัสดีครับ บทความนี้ จะมาแนะนำโปรแกรม การทำ dataset แบบ Object Detection ชนิด VOC ที่สามารถเอาไปใช้ตอนเทรนใน yolo2 ได้ ชึ่งโปรแกรมนี้ผมใช้มาตลอดครับ มันใช้คงใช้งานง่ายสำหรับผมนะครับแต่ไม่รู้เหมือนกันว่าคนอื่นจะใช้งานง่ายด้วยไหม การที่เราจะทำ dataset เองนั้นแปลว่า dataset ที่เราอยากได้นั้นมันไม่มีใครแจก เราจึงต้องทำเองใช้ไหมครับ แต่ถ้ามี dataset อยู่แล้ว ผมไม่แนะนำให้ทำเองนะครับเพราะ มันใช้เวลามากครับ
โปรแกรมที่ใช้เป็นตัวนี้ครับ (labelImg)\[]
(]
วิธีการโหลด คลิกตามที่ขีดเส้นไต้ครับ
แล้วคลิกตามที่ขีดเส้นไต้ครับ
หลังจากโหลดเสร็จ แตกไฟล์ เปิด labelImg.exe ได้เลยครับ หลังจากเปิดแล้ว ตั้งค่าตามรูปครับ
หลังจากตั้งค่าเสร็จแล้ว ต่อไปมา ปุ่มที่ต้องให้นะครับ
Open เปิดรูปที่เราจะเฉลย รูปเดียว
Open Dir เปิดรูปที่เราจะเฉลย ทั้ง folder
Change Save Dir เป็นที่อยู่ Annotation
ถ้าเป็น YOLO ให้เปลียนเป็น PascalVOC แต่ถ้าเป็น PascalVOC อยู่แล้วไม่ต้องเปลี่ยนครับ
ต่อไปเป็น KEY ลัดที่ผมชอบใช้ครับ
w คือ เอาใว้วาดกรอบว่าจะเอาจับอะไร d คือ เปลียนรูปถัดไป a คือ ย้อนกลับรูป เพื่อแก้ไข
หมายเหตุ การกด d,a เสร็จจะทำการบันทึกตลอด
File List คือตัวแสดงรูปทั้งหมดที่เราจะใส่ Object
Box Labels คือ หน้าต่าง ตั้งค่า Object ชื่ออะไร แต่ถ้าไม่อยากเพิ่มทุกครั้ง ให้ติก Use default label ตรงช่องว่างให้ใส่ ก็ใส่เป็นชื่อ Object ไปเลยครับ
ตัวอย่างเป็น วีดีโอ
[](http://www.youtube.com/watch?v=B0M7R0dK18U)
# CorgiDude บอร์ดกับการทำ License Plate Detection ของรถมอเตอร์ไซค์ โดยใช้ Yolo2
สวัสดีครับ วันนี้ผมมาแจก โมเดล ตรวจจับป้ายทะเบียนรถมอเตอร์ไซค์ แล้วมันจะมีประโยชน์อะไร มีครับ - เอาไปนับรถเข้าได้ - เอาไปตรวจจับรถมอเตอร์ไซค์บนทางเท้าได้แล้วถ่ายรูปส่งผ่าน Line (อันนี้ถ้าเอาไปให้ตำรวจอาจจะได้เงิน)
เรามาเริ่มกันเลยดีกว่า
ก่อนอื่นก็ต้องมี โมเดลก่อนครับ ลิ้งโหลดด้านล่างครับ
(]
ต่อไปก็ทำการ Flash model ที่ได้โหลดมาครับ หรื่อใคร Flash model ไม่เป็น ไปทำตามบทความตามลิ้งต่อไปนี้ครับ
(]
Flash ไปที่ตำแหน่ง 0x600000 เลยครับ
ต่อไปมาลอง Script ดูครับ
```python
import sensor,image,lcd,time
import KPU as kpu
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.set_windowing((224, 224))
sensor.set_vflip(1)
sensor.set_brightness(-2)
#sensor.set_contrast(-2)
sensor.run(1)
lcd.init(type=2, freq=20000000, color=lcd.BLACK)
lcd.rotation(2)
clock = time.clock()
classes = ["LI"]
task = kpu.load(0x600000)
#task = kpu.load("/sd/plate.kmodel")
a = kpu.set_outputs(task, 0, 7,7,30)
anchor = (0.45,0.50, 0.67,0.77, 0.91,1.08, 1.38,1.31, 2.45,2.19)
a = kpu.init_yolo2(task, 0.3, 0.3, 5, anchor)
time2 = 0
while(True):
time1 = time2
time2 = time.ticks_ms()
img = sensor.snapshot()
#a= img.resize(224,224)
#a = img.pix_to_ai()
code = kpu.run_yolo2(task, img)
if code:
for i in code:
a=img.draw_rectangle(i.rect(),color = (0, 255, 0),thickness=5)
a = lcd.display(img)
print(1000/(time2-time1))
a = kpu.deinit(task)
```
ตัวอย่างการทดสอบ
# CorgiDude บอร์ด ตรวจจับใบหน้า และ Mask ด้วย Yolo2 Face Mask Detection
สวัสดีครับ สำหรับบอร์ด CorgiDude ที่อยากจะทำ Face mask detection นั้น ครับ บทความนี้จะมาสอนใช้โมเดลที่เทรนมาแล้วนะครับ โดยก็จะมีหลักการ อยู่ 2 ข้้นตอนครับ 1 ผมนำรูปมา detection หาใบหน้าก่อนครับ ก็จะรันโมเดล Face detection จากบทความอันเก่าครับที่เคยเขียนมาครับ 2 ตัดรูปหน้าที่ detection เจอจากข้อ 1 เอามาทำ **Image Clssification** อีกรอบครับ ซึ่งดูๆ จะเห็นได้ว่าผมรัน 2 โมเดลต่อกัน
ก่อนอื่นก็ต้องมี โมเดลก่อนครับ ลิ้งโหลดด้านล่างครับ
โมเดล Face detection
(]
โมเดลนี้ Flash ไปที่ตำแหน่ง 0x300000 เลยครับ(นับ0ให้ครบนะครับถ้าใส่ผิดมีโอกาศพังครับ)
โมเดล mask
([https://github.com/AiDude-io/CorgiDude/blob/master/08 - Face Detection/f\_mask.kmodel)\[https://github.com/AiDude-io/CorgiDude/blob/master/08 - Face Detection/f\_mask.kmodel](https://github.com/AiDude-io/CorgiDude/blob/master/08%20-%20Face%20Detection/f_mask.kmodel\)\[https://github.com/AiDude-io/CorgiDude/blob/master/08%20-%20Face%20Detection/f_mask.kmodel)]
โมเดลนี้ Flash ไปที่ตำแหน่ง 0x600000 เลยครับ(นับ0ให้ครบนะครับถ้าใส่ผิดมีโอกาศพังครับ)
ต่อไปก็ทำการ Flash model ที่ได้โหลดมาครับ หรือใคร Flash model ไม่เป็น ไปทำตามบทความตามลิ้งต่อไปนี้ครับ
(]
หลังจากที่ Flash โมเดลเสร็จ ก็รับสคิปต่อไปนี้เลยครับ
```python
import uos
import sensor
import image
import lcd
import KPU as kpu
from fpioa_manager import fm
from machine import I2C
from board import board_info
from Maix import GPIO
lcd.init(type=2, freq=20000000, color=lcd.BLACK)
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
#sensor.set_windowing((224, 224))
sensor.set_vflip(1)
sensor.run(1)
fm.register(21, fm.fpioa.GPIOHS0, force=True)
fm.register(22, fm.fpioa.GPIOHS1, force=True)
D21 = GPIO(GPIO.GPIOHS0, GPIO.OUT)
RED = GPIO(GPIO.GPIOHS1, GPIO.OUT)
RED.value(0)
D21.value(1)
task = kpu.load(0x300000)
tid = kpu.load(0x600000)
anchor = (1.889, 2.5245, 2.9465, 3.94056, 3.99987, 5.3658, 5.155437, 6.92275, 6.718375, 9.01025)
a = kpu.init_yolo2(task, 0.5, 0.3, 5, anchor)
while(True):
img = sensor.snapshot()
code = kpu.run_yolo2(task, img)
if code:
for i in code:
xx = i.x()-10
yy = i.y()-10
ww = i.w()+15
hh = i.h()+10
face_cut=img.cut(xx,yy,ww,hh)
face_cut=face_cut.resize(128,128)
a = face_cut.pix_to_ai()
a = kpu.set_outputs(tid,0,1,1,2)
fmap = kpu.forward(tid,face_cut)
plist=fmap[:]
pmax=max(plist)
max_index=plist.index(pmax)
print(plist)
if plist[0] >= 0.94 :
a = img.draw_rectangle(xx, yy, ww, hh, color=(255,0,0), thickness=4)
elif plist[1] >= 0.98 :
a = img.draw_rectangle(xx, yy, ww, hh, color=(0,255,0), thickness=4)
else :
a = img.draw_rectangle(xx, yy, ww, hh, color=(0,0,255), thickness=4)
else :
RED.value(0)
D21.value(1)
a = lcd.display(img)
a = kpu.deinit(task)
```
ผลการทดสอบก็เป็นไปตามรูปต่อไปนี้ครับ
# Downloads
# Firmware
| Filename | Versions | Released | Download |
| --------------------------------- | -------- | ---------- | ------------------------------------------------------------------------------------------------------- |
| CorgiDude\_Firmware\_2020\_07\_25 | 1.1.1 | 2020-07-25 | [Download](https://github.com/AiDude-io/CorgiDude/releases/download/v1.1.1/corgidude_firmware_full.bin) |
# Models
| Filename | Versions | Date | Download |
| --------------------------- | -------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| Cat Face Detection | 1.0.0 | 2020-09-11 | [Download](https://github.com/AiDude-io/CorgiDude/raw/master/models/Cat_face_Detection/model006.kmodel) |
| Car License Plate Detection | 1.0.0 | 2021-01-18 | [Download](https://github.com/AiDude-io/CorgiDude/blob/master/models/CarLicensePlateDetection/license_plate_detector_0x400000.kmodel) |
| Face Detection | 1.0.0 | 2020-09-11 | [Download](https://github.com/AiDude-io/CorgiDude/raw/master/models/Face_detection/facedetect.kmodel) |
| License Plate Detection | 1.0.0 | 2020-09-11 | [Download](https://github.com/AiDude-io/CorgiDude/raw/master/models/License_Plate_Detection/LIIII_anchors_gen.kmodel) |
| MobileNetV1 1000 | 1.0.0 | 2020-09-11 | [Download](https://github.com/AiDude-io/CorgiDude/raw/master/models/MobilenetV1_1000/mbnet751.kmodel) |
| YOLOv2 | 2.0.0 | 2020-09-11 | [Download](https://github.com/AiDude-io/CorgiDude/raw/master/models/yolo2/20class.kmodel) |
| Face Mask YOLOv2 | 1.0.0 | 2020-09-22 | [Download](https://github.com/AiDude-io/CorgiDude/raw/master/models/f_mask_yolo2/F_mask_yolo2_k210.kmodel) |