1. บทนำ
สิ่งที่คุณจะสร้าง
ในโค้ดแล็บนี้ เราจะเรียนรู้วิธีใช้ TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์เพื่อเรียกใช้โมเดล Deep Learning บน SparkFun Edge Development Board เราจะทำงานร่วมกับโมเดลการตรวจจับคำพูดในตัวของบอร์ด ซึ่งใช้โครงข่ายประสาทแบบคอนโวลูชันเพื่อตรวจจับคำว่า "ใช่" และ "ไม่" ที่พูดผ่านไมโครโฟน 2 ตัวของบอร์ด
แมชชีนเลิร์นนิงในไมโครคอนโทรลเลอร์
แมชชีนเลิร์นนิงสามารถใช้สร้างเครื่องมืออัจฉริยะที่ช่วยให้ชีวิตของผู้ใช้สะดวกสบายขึ้น เช่น Google Assistant แต่บ่อยครั้งที่ประสบการณ์เหล่านี้ต้องใช้การคำนวณหรือทรัพยากรจำนวนมาก ซึ่งอาจรวมถึงเซิร์ฟเวอร์ระบบคลาวด์หรือเดสก์ท็อปที่มีประสิทธิภาพ อย่างไรก็ตาม ปัจจุบันคุณสามารถเรียกใช้การอนุมานแมชชีนเลิร์นนิงในฮาร์ดแวร์ขนาดเล็กที่ใช้พลังงานต่ำ เช่น ไมโครคอนโทรลเลอร์
ไมโครคอนโทรลเลอร์เป็นอุปกรณ์ที่พบได้ทั่วไป ราคาถูก ใช้พลังงานน้อยมาก และมีความน่าเชื่อถือสูง ซึ่งเป็นส่วนหนึ่งของอุปกรณ์ในบ้านทุกประเภท ไม่ว่าจะเป็นเครื่องใช้ไฟฟ้า รถยนต์ และของเล่น ในแต่ละปีมีการผลิตอุปกรณ์ที่ใช้ไมโครคอนโทรลเลอร์ประมาณ 3 หมื่นล้านเครื่อง
การนำแมชชีนเลิร์นนิงมาใช้กับไมโครคอนโทรลเลอร์ขนาดเล็กช่วยเพิ่มความอัจฉริยะให้กับอุปกรณ์หลายพันล้านชิ้นที่เราใช้ในชีวิตประจำวันได้โดยไม่ต้องพึ่งพาฮาร์ดแวร์ราคาแพงหรือการเชื่อมต่ออินเทอร์เน็ตที่เสถียร ลองนึกภาพเครื่องใช้ไฟฟ้าอัจฉริยะที่ปรับเปลี่ยนให้เข้ากับกิจวัตรประจำวันของคุณ เซ็นเซอร์อุตสาหกรรมอัจฉริยะที่เข้าใจความแตกต่างระหว่างปัญหาและการทำงานปกติ รวมถึงของเล่นมหัศจรรย์ที่ช่วยให้เด็กๆ เรียนรู้ได้อย่างสนุกสนานและเพลิดเพลิน
TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์ (ซอฟต์แวร์)
TensorFlow คือเฟรมเวิร์กแมชชีนเลิร์นนิงแบบโอเพนซอร์สของ Google สำหรับการฝึกและเรียกใช้โมเดล TensorFlow Lite เป็นเฟรมเวิร์กซอฟต์แวร์ ซึ่งเป็น TensorFlow เวอร์ชันที่เพิ่มประสิทธิภาพแล้ว โดยมีเป้าหมายเพื่อเรียกใช้โมเดล TensorFlow บนอุปกรณ์ขนาดเล็กที่มีกำลังค่อนข้างต่ำ เช่น โทรศัพท์มือถือ
TensorFlow Lite For Microcontrollers เป็นเฟรมเวิร์กซอฟต์แวร์ ซึ่งเป็น TensorFlow เวอร์ชันที่เพิ่มประสิทธิภาพแล้ว โดยมีเป้าหมายเพื่อเรียกใช้โมเดล TensorFlow บนฮาร์ดแวร์ขนาดเล็กที่ใช้พลังงานต่ำ เช่น ไมโครคอนโทรลเลอร์ โดยเป็นไปตามข้อจำกัดที่จำเป็นในสภาพแวดล้อมแบบฝังเหล่านี้ กล่าวคือ มีไบนารีขนาดเล็ก ไม่ต้องใช้การสนับสนุนระบบปฏิบัติการ ไลบรารี C หรือ C++ มาตรฐาน หรือการจัดสรรหน่วยความจำแบบไดนามิก เป็นต้น
SparkFun Edge (ฮาร์ดแวร์)
SparkFun Edge เป็นแพลตฟอร์มที่ใช้ไมโครคอนโทรลเลอร์ ซึ่งเป็นคอมพิวเตอร์ขนาดเล็กบนแผงวงจรเดียว โดยมีโปรเซสเซอร์ หน่วยความจำ และฮาร์ดแวร์ I/O ที่ช่วยให้ส่งและรับสัญญาณดิจิทัลไปยังอุปกรณ์อื่นๆ ได้ โดยมีไฟ LED 4 ดวงที่ควบคุมด้วยซอฟต์แวร์ในสี Google ที่คุณชื่นชอบ
ไมโครคอนโทรลเลอร์ไม่เหมือนคอมพิวเตอร์ตรงที่จะไม่เรียกใช้ระบบปฏิบัติการ แต่โปรแกรมที่คุณเขียนจะทำงานบนฮาร์ดแวร์โดยตรง คุณเขียนโค้ดในคอมพิวเตอร์และดาวน์โหลดลงในไมโครคอนโทรลเลอร์ผ่านอุปกรณ์ที่เรียกว่าโปรแกรมเมอร์
ไมโครคอนโทรลเลอร์ไม่ใช่คอมพิวเตอร์ที่มีประสิทธิภาพ โดยมีโปรเซสเซอร์ขนาดเล็กและหน่วยความจำไม่มาก แต่เนื่องจากออกแบบมาให้ใช้งานง่ายที่สุด ไมโครคอนโทรลเลอร์จึงใช้พลังงานน้อยมาก SparkFun Edge ทำงานได้นานหลายสัปดาห์ด้วยแบตเตอรี่แบบเหรียญเพียงก้อนเดียว ทั้งนี้ขึ้นอยู่กับสิ่งที่โปรแกรมของคุณทำ
สิ่งที่คุณจะได้เรียนรู้
- คอมไพล์โปรแกรมตัวอย่างสำหรับ SparkFun Edge ในคอมพิวเตอร์
- ติดตั้งโปรแกรมในอุปกรณ์
- ทำการเปลี่ยนแปลงโปรแกรมและติดตั้งใช้งานอีกครั้ง
สิ่งที่คุณต้องมี
คุณจะต้องมีฮาร์ดแวร์ต่อไปนี้
- คอมพิวเตอร์ Linux หรือ MacOS
- บอร์ด SparkFun Edge
- โปรแกรมเมอร์ SparkFun USB-C Serial Basic
- สาย USB-C กับ USB-A (หากใช้คอมพิวเตอร์ USB-C ให้ใช้สาย USB-C กับ USB-C แทน)
- (ไม่บังคับ) แบตเตอรี่ลิเธียมแบบเหรียญขนาด 3 โวลต์ 20 มม. (CR2032) เพื่อเรียกใช้การอนุมานโดยไม่ต้องใช้โปรแกรมเมอร์และสายเคเบิล
คุณจะต้องมีซอฟต์แวร์ต่อไปนี้
- Git (ตรวจสอบว่าติดตั้งแล้วโดยเรียกใช้
gitในบรรทัดคำสั่ง) - Python 3 (ตรวจสอบว่าติดตั้งแล้วโดยเรียกใช้
python3หรือpython --versionในบรรทัดคำสั่ง) - Pip สำหรับ Python 3 ( คำตอบที่เป็นประโยชน์ใน StackOverflow)
- เวอร์ชัน 4.2.1 ขึ้นไป (ตรวจสอบว่าติดตั้งแล้วหรือไม่โดยเรียกใช้
make --versionในบรรทัดคำสั่ง) - ไดรเวอร์ SparkFun Serial Basic
2. ตั้งค่าฮาร์ดแวร์
ไมโครคอนโทรลเลอร์ SparkFun Edge มาพร้อมไบนารีที่ติดตั้งไว้ล่วงหน้าซึ่งสามารถเรียกใช้โมเดลคำพูดได้ ก่อนที่เราจะเขียนทับด้วยเวอร์ชันของเราเอง มาลองใช้โมเดลนี้กันก่อน
เพิ่มพลังให้บอร์ดโดยทำดังนี้
- ใส่แบตเตอรี่แบบเหรียญลงในขั้วต่อแบตเตอรี่ที่ด้านหลังของบอร์ด (โดยให้ด้าน "+" ของแบตเตอรี่หงายขึ้น) หากบอร์ดมีแบตเตอรี่เสียบอยู่แล้ว ให้ดึงแถบพลาสติกออก แล้วดันแบตเตอรี่เพื่อให้เสียบเข้าไปจนสุด)
- หากไม่มีแบตเตอรี่แบบเหรียญ คุณสามารถใช้อุปกรณ์โปรแกรมเมอร์ SparkFun USB-C Serial Basic เพื่อจ่ายไฟให้กับบอร์ดได้ หากต้องการติดอุปกรณ์นี้กับบอร์ด ให้ทำตามขั้นตอนต่อไปนี้
- มองหาส่วนหัวแบบ 6 พินที่ด้านข้างของ SparkFun Edge
- เสียบ SparkFun USB-C Serial Basic เข้ากับพินเหล่านี้ โดยตรวจสอบว่าพินที่มีป้ายกำกับ "BLK" และ "GRN" ในแต่ละอุปกรณ์ตรงกันอย่างถูกต้อง
- เชื่อมต่อสาย USB-C ระหว่าง SparkFun USB-C Serial Basic กับคอมพิวเตอร์
เมื่อเปิดบอร์ดโดยใส่แบตเตอรี่หรือเชื่อมต่อโปรแกรมเมอร์ USB แล้ว บอร์ดจะตื่นขึ้นและเริ่มฟังด้วยไมโครโฟน ไฟสีน้ำเงินควรเริ่มกะพริบ
โมเดลแมชชีนเลิร์นนิงในบอร์ดได้รับการฝึกให้จดจำคำว่า "ใช่" และ "ไม่" รวมถึงตรวจหาการมีอยู่และไม่มีอยู่ของคำพูด โดยจะสื่อสารผลลัพธ์ด้วยการเปิดไฟ LED สี ตารางต่อไปนี้แสดงความหมายของสี LED แต่ละสี
ผลการตรวจจับ | สี LED |
"ใช่" | เหลือง |
"ไม่" | แดง |
คำพูดที่ไม่รู้จัก | เขียว |
ไม่พบคำพูด | ไม่มีไฟ LED ติด |
ลองใช้เลย
ถือบอร์ดไว้ที่ปากแล้วพูดว่า "ใช่" 2-3 ครั้ง คุณจะเห็นไฟ LED สีเหลืองกะพริบ หากไม่มีอะไรเกิดขึ้นเมื่อคุณพูดว่า "ใช่" ให้ลองทำดังนี้
- ถือบอร์ดให้ห่างจากปากประมาณ 10 นิ้ว
- หลีกเลี่ยงเสียงรบกวนรอบข้างมากเกินไป
- พูดว่า "ใช่" หลายครั้งติดต่อกันอย่างรวดเร็ว (ลองพูดว่า "ใช่ ใช่ ใช่")
3. ตั้งค่าซอฟต์แวร์
ตอนนี้เราจะดาวน์โหลด ติดตั้ง และเรียกใช้โมเดลคำพูดบนไมโครคอนโทรลเลอร์ด้วยตัวเราเอง โดยเราจะดาวน์โหลดซอร์สโค้ดของโปรแกรมนี้และทรัพยากร Dependency ที่จำเป็นต่อการสร้างก่อน โปรแกรมเขียนด้วยภาษา C++ ซึ่งต้องคอมไพล์เป็นไบนารีก่อนจึงจะดาวน์โหลดลงในบอร์ดได้ ไบนารีคือไฟล์ที่มีโปรแกรมในรูปแบบที่ฮาร์ดแวร์ SparkFun Edge เรียกใช้ได้โดยตรง
วิธีการต่อไปนี้เขียนขึ้นสำหรับ Linux หรือ MacOS
ดาวน์โหลดที่เก็บ TensorFlow
โค้ดนี้อยู่ในที่เก็บ TensorFlow บน GitHub ในตำแหน่งต่อไปนี้
https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite/micro
เปิดเทอร์มินัลในคอมพิวเตอร์ เปลี่ยนเป็นไดเรกทอรีที่คุณมักจะจัดเก็บโปรเจ็กต์การเขียนโค้ด ดาวน์โหลดที่เก็บ TensorFlow และเข้าสู่ไดเรกทอรีที่สร้างขึ้น ดังที่แสดงด้านล่าง
cd ~ # change into your home (or any other) directory git clone --depth 1 https://github.com/tensorflow/tensorflow.git cd tensorflow
ดาวน์โหลดทรัพยากร Dependency ของ Python
เราจะใช้ Python 3 เพื่อเตรียมไบนารีและแฟลชลงในอุปกรณ์ สคริปต์ Python ขึ้นอยู่กับไลบรารีบางรายการที่พร้อมใช้งาน เรียกใช้คำสั่งต่อไปนี้เพื่อติดตั้งทรัพยากร Dependency เหล่านี้
pip3 install pycrypto pyserial --user
4. สร้างและเตรียมไบนารี
เราจะสร้างไบนารีและเรียกใช้คำสั่งที่เตรียมไบนารีสำหรับการดาวน์โหลดลงในอุปกรณ์
สร้างไบนารี
หากต้องการดาวน์โหลดทรัพยากร Dependency ที่จำเป็นทั้งหมดและสร้างไบนารี ให้เรียกใช้คำสั่งต่อไปนี้
make -f tensorflow/lite/micro/tools/make/Makefile TARGET=sparkfun_edge micro_speech_bin
หากการสร้างทำงานสำเร็จ บรรทัดสุดท้ายของเอาต์พุตควรมีลักษณะดังนี้
arm-none-eabi-objcopy tensorflow/lite/micro/tools/make/gen/sparkfun_edge_cortex-m4/bin/micro_speech tensorflow/lite/micro/tools/make/gen/sparkfun_edge_cortex-m4/bin/micro_speech.bin -O binary
หากต้องการยืนยันว่าสร้างไบนารีสำเร็จแล้ว ให้เรียกใช้คำสั่งต่อไปนี้
test -f \ tensorflow/lite/micro/tools/make/gen/sparkfun_edge_cortex-m4/bin/micro_speech.bin && \ echo "Binary was successfully created" || echo "Binary is missing"
คุณควรเห็น Binary was successfully created พิมพ์ลงในคอนโซล หากเห็น Binary is missing แสดงว่ากระบวนการบิลด์มีปัญหาซึ่งต้องมีการแก้ไขข้อบกพร่อง
เตรียมไบนารี
ต้องลงนามไบนารีด้วยคีย์การเข้ารหัสลับเพื่อนำไปใช้กับอุปกรณ์ ตอนนี้เราจะเรียกใช้คำสั่งบางอย่างที่จะลงนามในไบนารีเพื่อให้ดาวน์โหลดลงใน SparkFun Edge ได้
ป้อนคำสั่งต่อไปนี้เพื่อตั้งค่าคีย์การเข้ารหัสจำลองบางรายการที่เราใช้ในการพัฒนาได้
cp tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/keys_info0.py tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/keys_info.py
ตอนนี้ให้เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างไบนารีที่ลงนามแล้ว
python3 tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/create_cust_image_blob.py \ --bin tensorflow/lite/micro/tools/make/gen/sparkfun_edge_cortex-m4/bin/micro_speech.bin \ --load-address 0xC000 \ --magic-num 0xCB \ -o main_nonsecure_ota \ --version 0x0
การดำเนินการนี้จะสร้างไฟล์ main_nonsecure_ota.bin ตอนนี้เราจะเรียกใช้คำสั่งอื่นเพื่อสร้างไฟล์เวอร์ชันสุดท้ายที่ใช้แฟลชอุปกรณ์ด้วยสคริปต์ Bootloader ที่เราจะใช้ในขั้นตอนถัดไปได้
python3 tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/create_cust_wireupdate_blob.py \ --load-address 0x20000 \ --bin main_nonsecure_ota.bin \ -i 6 \ -o main_nonsecure_wire \ --options 0x1
ตอนนี้คุณควรมีไฟล์ชื่อ main_nonsecure_wire.bin ในไดเรกทอรีที่คุณเรียกใช้คำสั่ง นี่คือไฟล์ที่เราจะแฟลชลงในอุปกรณ์
5. เตรียมพร้อมแฟลชไบนารี
การแฟลชคืออะไร
SparkFun Edge จะจัดเก็บโปรแกรมที่กำลังทำงานอยู่ในหน่วยความจำแฟลชขนาด 512 กิโลไบต์ หากเราต้องการให้บอร์ดเรียกใช้โปรแกรมใหม่ เราต้องส่งโปรแกรมนั้นไปยังบอร์ด ซึ่งจะจัดเก็บไว้ในหน่วยความจำแฟลชและเขียนทับโปรแกรมที่บันทึกไว้ก่อนหน้านี้
กระบวนการนี้เรียกว่า "การแฟลช" และเราจะใช้กระบวนการนี้เพื่อส่งโปรแกรมไปยังบอร์ด
ต่อโปรแกรมเมอร์เข้ากับบอร์ด
เราจะใช้โปรแกรมเมอร์แบบอนุกรม SparkFun USB-C Serial Basic เพื่อดาวน์โหลดโปรแกรมใหม่ๆ ลงในบอร์ด อุปกรณ์นี้ช่วยให้คอมพิวเตอร์สื่อสารกับไมโครคอนโทรลเลอร์ผ่าน USB ได้
หากต้องการติดอุปกรณ์นี้กับบอร์ด ให้ทำตามขั้นตอนต่อไปนี้
- มองหาส่วนหัวแบบ 6 พินที่ด้านข้างของ SparkFun Edge
- เสียบ SparkFun USB-C Serial Basic เข้ากับพินเหล่านี้ โดยตรวจสอบว่าพินที่มีป้ายกำกับ "BLK" และ "GRN" ในแต่ละอุปกรณ์ตรงกันอย่างถูกต้อง
ต่อโปรแกรมเมอร์กับคอมพิวเตอร์
เราจะเชื่อมต่อบอร์ดกับคอมพิวเตอร์ผ่าน USB หากต้องการตั้งโปรแกรมบอร์ด เราจะต้องทราบชื่อที่คอมพิวเตอร์ตั้งให้กับอุปกรณ์ วิธีที่ดีที่สุดในการทำเช่นนี้คือการแสดงรายการอุปกรณ์ทั้งหมดของคอมพิวเตอร์ก่อนและหลังการเชื่อมต่อ แล้วดูว่าอุปกรณ์ใดเป็นอุปกรณ์ใหม่
ก่อนที่จะแนบอุปกรณ์ผ่าน USB ให้เรียกใช้คำสั่งต่อไปนี้
If you are using Linux: ls /dev/tty* If you are using MacOS: ls /dev/cu*
ซึ่งควรแสดงรายการอุปกรณ์ที่เชื่อมต่อที่มีลักษณะดังนี้
/dev/cu.Bluetooth-Incoming-Port /dev/cu.MALS /dev/cu.SOC
ตอนนี้ให้เชื่อมต่อโปรแกรมเมอร์กับพอร์ต USB ของคอมพิวเตอร์ ป้อนคำสั่งต่อไปนี้อีกครั้ง
If you are using Linux: ls /dev/tty* If you are using MacOS: ls /dev/cu*
คุณควรเห็นรายการเพิ่มเติมในเอาต์พุต ดังตัวอย่างด้านล่าง รายการใหม่ของคุณอาจมีชื่อแตกต่างกัน รายการใหม่นี้คือชื่อของอุปกรณ์
/dev/cu.Bluetooth-Incoming-Port /dev/cu.MALS /dev/cu.SOC /dev/cu.wchusbserial-1450
ก่อนอื่น เราจะสร้างตัวแปรสภาพแวดล้อมเพื่อระบุชื่ออุปกรณ์
export DEVICENAME=put your device name here
จากนั้นเราจะสร้างตัวแปรสภาพแวดล้อมเพื่อระบุอัตราบอด ซึ่งเป็นความเร็วที่จะใช้ส่งข้อมูลไปยังอุปกรณ์
export BAUD_RATE=921600
6. แฟลชไบนารี
เรียกใช้สคริปต์เพื่อแฟลชบอร์ด
หากต้องการแฟลชบอร์ด เราต้องเปลี่ยนบอร์ดให้อยู่ในสถานะ "Bootloader" พิเศษที่เตรียมพร้อมรับไบนารีใหม่ จากนั้นเราจะเรียกใช้สคริปต์เพื่อส่งไบนารีไปยังบอร์ด
มาทำความคุ้นเคยกับปุ่มต่อไปนี้บนกระดานกัน
ทำตามขั้นตอนต่อไปนี้เพื่อรีเซ็ตและแฟลชบอร์ด
- ตรวจสอบว่าบอร์ดเชื่อมต่อกับโปรแกรมเมอร์ และการตั้งค่าทั้งหมดเชื่อมต่อกับคอมพิวเตอร์ผ่าน USB
- เริ่มกดปุ่มที่ทำเครื่องหมาย
14บนบอร์ดค้างไว้ กดค้างไว้จนถึงขั้นตอนที่ 6 - ขณะที่ยังกดปุ่มที่ทำเครื่องหมาย
14อยู่ ให้คลิกปุ่มที่ทำเครื่องหมายRSTเพื่อรีเซ็ตบอร์ดเพื่อรีเซ็ตบอร์ดให้อยู่ในสถานะ Bootloader - ขณะที่ยังกดปุ่มที่ทำเครื่องหมาย
14ค้างไว้ ให้วางคำสั่งต่อไปนี้ลงในเทอร์มินัลแล้วกด Enter เพื่อเรียกใช้ (เพื่อความสะดวก คุณสามารถวางคำสั่งนี้ลงในเทอร์มินัลก่อนที่จะเริ่มกดปุ่มค้างไว้ได้ แต่ไม่ต้องกด Enter จนกว่าจะถึงขั้นตอนนี้)
python3 tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/uart_wired_update.py -b ${BAUD_RATE} ${DEVICENAME} -r 1 -f main_nonsecure_wire.bin -i 6
- ขณะที่ยังกดปุ่มที่มีเครื่องหมาย
14ค้างไว้ คุณควรเห็นข้อความต่อไปนี้ปรากฏบนหน้าจอ
Connecting with Corvette over serial port /dev/cu.usbserial-1440... Sending Hello. Received response for Hello Received Status length = 0x58 version = 0x3 Max Storage = 0x4ffa0 Status = 0x2 State = 0x7 AMInfo = 0x1 0xff2da3ff 0x55fff 0x1 0x49f40003 0xffffffff [...lots more 0xffffffff...] Sending OTA Descriptor = 0xfe000 Sending Update Command. number of updates needed = 1 Sending block of size 0x158b0 from 0x0 to 0x158b0 Sending Data Packet of length 8180 Sending Data Packet of length 8180 [...lots more Sending Data Packet of length 8180...]
- หยุดกดปุ่มที่มีเครื่องหมาย
14บนบอร์ดหลังจากเห็นSending Data Packet of length 8180(แต่ไม่เป็นไรหากคุณกดค้างไว้) โปรแกรมจะยังคงพิมพ์บรรทัดในเทอร์มินัลต่อไป ซึ่งในที่สุดจะมีลักษณะดังนี้
[...lots more Sending Data Packet of length 8180...] Sending Data Packet of length 8180 Sending Data Packet of length 6440 Sending Reset Command. Done.
หากเห็น Done แสดงว่าการกะพริบสำเร็จ หากเอาต์พุตของโปรแกรมลงท้ายด้วยข้อผิดพลาด ให้ตรวจสอบว่ามีการพิมพ์ Sending Reset Command หรือไม่ หากเป็นเช่นนั้น การแฟลชอาจสำเร็จแม้จะมีข้อผิดพลาด
ในเครื่อง Linux คุณอาจพบ NoResponse Error เนื่องจากมีการติดตั้งไดรเวอร์อนุกรม ch34x ควบคู่ไปกับไดรเวอร์อนุกรมที่มีอยู่ ซึ่งแก้ไขได้โดยทำดังนี้
ขั้นตอนที่ 1: ติดตั้งไลบรารี ch34x เวอร์ชันที่ถูกต้องอีกครั้ง ตรวจสอบว่าได้ถอดปลั๊กอุปกรณ์ออกจากคอมพิวเตอร์แล้วในระหว่างการติดตั้ง
git clone https://github.com/juliagoda/CH341SER.git cd CH341SER/ make sudo insmod ch34x.ko sudo rmmod ch341
ขั้นตอนที่ 2: เสียบ USB ของบอร์ดแล้วเรียกใช้คำสั่งต่อไปนี้
dmesg | grep "ch34x"
คุณควรเห็นข้อความดังนี้
[ 1299.444724] ch34x_attach+0x1af/0x280 [ch34x] [ 1299.445386] usb 2-13.1: ch34x converter now attached to ttyUSB0
หากไดรเวอร์ที่ใช้ไม่ใช่ "ch34x" (เช่น ch341) ให้ลองปิดใช้ไดรเวอร์อื่นโดยเรียกใช้คำสั่งต่อไปนี้
rmmod <non-ch34x driver name>
ถอดปลั๊กและเสียบปลั๊กอุปกรณ์อีกครั้ง แล้วตรวจสอบว่าไดรเวอร์ที่ใช้คือ "ch34x"
7. สาธิต
ลองใช้โปรแกรม
เมื่อแฟลชบอร์ดเรียบร้อยแล้ว ให้กดปุ่มที่มีเครื่องหมาย
RST เพื่อรีสตาร์ทบอร์ดและเริ่มโปรแกรม หากไฟ LED สีน้ำเงินเริ่มกะพริบ แสดงว่าการกะพริบไฟสำเร็จ หากไม่เห็น ให้เลื่อนลงไปที่ส่วน "ฉันควรทำอย่างไรหากไม่ได้ผล" ด้านล่าง
โมเดลแมชชีนเลิร์นนิงในบอร์ดได้รับการฝึกให้จดจำคำว่า "ใช่" และ "ไม่" รวมถึงตรวจหาการมีอยู่และไม่มีอยู่ของคำพูด โดยจะสื่อสารผลลัพธ์ด้วยการเปิดไฟ LED สี ตารางต่อไปนี้แสดงความหมายของสี LED แต่ละสี
ผลการตรวจจับ | สี LED |
"ใช่" | เหลือง |
"ไม่" | แดง |
คำพูดที่ไม่รู้จัก | เขียว |
ไม่พบคำพูด | ไม่มีไฟ LED ติด |
ลองใช้เลย
ถือบอร์ดไว้ที่ปากแล้วพูดว่า "ใช่" 2-3 ครั้ง คุณจะเห็นไฟ LED สีเหลืองกะพริบ หากไม่มีอะไรเกิดขึ้นเมื่อคุณพูดว่า "ใช่" ให้ลองทำดังนี้
- ถือบอร์ดให้ห่างจากปากประมาณ 10 นิ้ว
- หลีกเลี่ยงเสียงรบกวนรอบข้างมากเกินไป
- พูดว่า "ใช่" หลายครั้งติดต่อกันอย่างรวดเร็ว (ลองพูดว่า "ใช่ ใช่ ใช่")
หากไม่ได้ผล ฉันควรทำอย่างไร
ปัญหาที่อาจเกิดขึ้นและวิธีแก้ไขมีดังนี้
ปัญหา: หลังจากแฟลชแล้ว ไม่มีไฟ LED ติด
วิธีแก้ปัญหา: ลองกดปุ่ม RST หรือยกเลิกการเชื่อมต่อและเชื่อมต่อบอร์ดจากโปรแกรมเมอร์อีกครั้ง หากวิธีเหล่านี้ไม่ได้ผล ให้ลองแฟลชบอร์ดอีกครั้ง
ปัญหา: ไฟ LED สีน้ำเงินสว่างขึ้น แต่สว่างน้อยมาก
วิธีแก้ปัญหา: เปลี่ยนแบตเตอรี่เนื่องจากแบตเตอรี่เหลือน้อย หรือจะจ่ายไฟให้บอร์ดจากคอมพิวเตอร์โดยใช้โปรแกรมเมอร์และสายเคเบิลก็ได้
8. อ่านเอาต์พุตการแก้ไขข้อบกพร่อง (ไม่บังคับ)
โปรดอ่านส่วนนี้หากพบปัญหาและต้องการแก้ไขข้อบกพร่องของโค้ดอย่างละเอียด หากต้องการทำความเข้าใจสิ่งที่เกิดขึ้นในไมโครคอนโทรลเลอร์เมื่อโค้ดทำงาน คุณสามารถพิมพ์ข้อมูลการแก้ไขข้อบกพร่องผ่านการเชื่อมต่อแบบอนุกรมของบอร์ด คุณใช้คอมพิวเตอร์เพื่อเชื่อมต่อกับบอร์ดและแสดงข้อมูลที่บอร์ดส่ง
เปิดการเชื่อมต่อแบบอนุกรม
โดยค่าเริ่มต้น โค้ดตัวอย่าง SparkFun Edge จะบันทึกคำสั่งที่พูดพร้อมกับความน่าเชื่อถือ หากต้องการดูเอาต์พุตของบอร์ด ให้เรียกใช้คำสั่งต่อไปนี้
screen ${DEVICENAME} 115200
ในตอนแรก คุณอาจเห็นเอาต์พุตที่มีลักษณะคล้ายกับตัวอย่างต่อไปนี้ (ข้อความนี้จะปรากฏขึ้นก็ต่อเมื่อรีเซ็ตบอร์ดเมื่อเชื่อมต่อแล้วเท่านั้น ไม่เช่นนั้นคุณอาจเริ่มเห็นข้อมูลการแก้ไขข้อบกพร่อง)
Apollo3 Burst Mode is Available
Apollo3 operating in Burst Mode (96MHz)
ลองออกคำสั่งโดยพูดว่า "ใช่" หรือ "ไม่" คุณควรเห็นข้อมูลการแก้ไขข้อบกพร่องในการพิมพ์บอร์ดสำหรับแต่ละคำสั่งดังนี้
Heard yes (202) @65536ms
ในบันทึกข้างต้น yes หมายถึงคำสั่ง หมายเลข 202 หมายถึงระดับความเชื่อมั่นว่าระบบได้ยินคำสั่ง (โดยมี 200 เป็นค่าต่ำสุด) สุดท้าย 65536ms หมายถึงระยะเวลาที่ผ่านไปนับตั้งแต่รีเซ็ตไมโครคอนโทรลเลอร์ครั้งล่าสุด
หากต้องการหยุดดูเอาต์พุตการแก้ไขข้อบกพร่อง ให้กด Ctrl+A ตามด้วยปุ่ม K ทันที แล้วกดปุ่ม Y
เขียนบันทึกการแก้ไขข้อบกพร่อง
คุณดูโค้ดที่บันทึกข้อมูลนี้ได้ในไฟล์ command_responder.cc ที่คุณเพิ่งทำงานด้วย
tensorflow/lite/micro/examples/micro_speech/sparkfun_edge/command_responder.cc
หากต้องการบันทึกข้อมูล ให้เรียกใช้เมธอด error_reporter->Report() โดยรองรับโทเค็น printf มาตรฐานสำหรับการแทรกสตริง ซึ่งคุณสามารถใช้เพื่อรวมข้อมูลสำคัญไว้ในบันทึกได้
error_reporter->Report("Heard %s (%d) @%dms", found_command, score, current_time);
วิธีนี้จะมีประโยชน์เมื่อคุณทำการเปลี่ยนแปลงโค้ดด้วยตนเองในส่วนถัดไป
9. ขยายโค้ด (ไม่บังคับ)
เมื่อทราบวิธีสร้างและแฟลช SparkFun Edge แล้ว คุณก็เริ่มเล่นกับโค้ดและนำไปใช้กับอุปกรณ์เพื่อดูผลลัพธ์ได้
อ่านรหัส
จุดเริ่มต้นที่ดีในการอ่านโค้ดคือไฟล์ command_responder.cc.
tensorflow/lite/micro/examples/micro_speech/sparkfun_edge/command_responder.cc
คุณดูไฟล์ได้ใน GitHub ที่นี่
ระบบจะเรียกใช้เมธอดในไฟล์นี้ RespondToCommand เมื่อตรวจพบคำสั่งเสียง โค้ดที่มีอยู่จะเปิดไฟ LED ที่แตกต่างกันโดยขึ้นอยู่กับว่าได้ยินคำสั่ง "ใช่" "ไม่" หรือคำสั่งที่ไม่รู้จัก ข้อมูลโค้ดต่อไปนี้แสดงวิธีการทำงาน
if (found_command[0] == 'y') {
am_hal_gpio_output_set(AM_BSP_GPIO_LED_YELLOW);
}
if (found_command[0] == 'n') {
am_hal_gpio_output_set(AM_BSP_GPIO_LED_RED);
}
if (found_command[0] == 'u') {
am_hal_gpio_output_set(AM_BSP_GPIO_LED_GREEN);
}
อาร์กิวเมนต์ found_command มีชื่อของคำสั่งที่ตรวจพบ การตรวจสอบอักขระแรกในชุดคำสั่ง if นี้จะช่วยกำหนดว่าควรเปิดไฟ LED ใด
มีการเรียกใช้เมธอด RespondToCommand โดยมีอาร์กิวเมนต์หลายรายการ ดังนี้
void RespondToCommand(tflite::ErrorReporter* error_reporter,
int32_t current_time, const char* found_command,
uint8_t score, bool is_new_command) {
error_reporterใช้เพื่อบันทึกข้อมูลการแก้ไขข้อบกพร่อง (ดูข้อมูลเพิ่มเติมในภายหลัง)current_timeแสดงเวลาที่ตรวจพบคำสั่งfound_commandจะบอกว่าตรวจพบคำสั่งใดscoreบอกให้เราทราบระดับความมั่นใจว่าเราตรวจพบคำสั่งis_new_commandแจ้งให้เราทราบหากคุณเพิ่งเคยได้ยินคำสั่งนี้เป็นครั้งแรก
score คือจำนวนเต็มตั้งแต่ 0-255 ที่แสดงถึงความน่าจะเป็นที่ตรวจพบคำสั่ง โค้ดตัวอย่างจะถือว่าคำสั่งใช้ได้ก็ต่อเมื่อคะแนนมากกว่า 200 จากการทดสอบของเรา คำสั่งที่ถูกต้องส่วนใหญ่จะอยู่ในช่วง 200-210
แก้ไขโค้ด
บอร์ด SparkFun Edge มี LED 4 ดวง ปัจจุบันเรากะพริบไฟ LED สีน้ำเงินเพื่อระบุว่าระบบกำลังจดจำ คุณจะเห็นข้อมูลนี้ในไฟล์ command_responder.cc
static int count = 0;
// Toggle the blue LED every time an inference is performed.
++count;
if (count & 1) {
am_hal_gpio_output_set(AM_BSP_GPIO_LED_BLUE);
} else {
am_hal_gpio_output_clear(AM_BSP_GPIO_LED_BLUE);
}
เนื่องจากเรามีหลอด LED 4 หลอด เรามาแก้ไขโปรแกรมเพื่อใช้เป็นตัวบ่งชี้ภาพของscoreคำสั่งที่กำหนดกัน คะแนนต่ำจะทำให้ไฟ LED สว่าง 1 ดวง และคะแนนสูงจะทำให้ไฟหลายดวงสว่าง
เพื่อให้เราทราบว่าโปรแกรมกำลังทำงานอยู่ เราจะทำให้ไฟ LED สีแดงกะพริบอย่างต่อเนื่องแทนสีน้ำเงิน ไฟ LED สีน้ำเงิน เขียว และเหลืองที่อยู่ติดกันจะใช้เพื่อแสดงความแรงของ score ล่าสุด และเพื่อความเรียบง่าย เราจะเปิดไฟ LED เหล่านั้นเฉพาะเมื่อมีการพูดคำว่า "ใช่" เท่านั้น หากตรวจพบคำอื่น ไฟ LED จะดับ
หากต้องการทำการเปลี่ยนแปลงนี้ ให้แทนที่โค้ดทั้งหมดในไฟล์ command_responder.cc ด้วยข้อมูลโค้ดต่อไปนี้
#include "tensorflow/lite/micro/examples/micro_speech/command_responder.h"
#include "am_bsp.h"
// This implementation will light up the LEDs on the board in response to different commands.
void RespondToCommand(tflite::ErrorReporter* error_reporter,
int32_t current_time, const char* found_command,
uint8_t score, bool is_new_command) {
static bool is_initialized = false;
if (!is_initialized) {
// Setup LEDs as outputs
am_hal_gpio_pinconfig(AM_BSP_GPIO_LED_RED, g_AM_HAL_GPIO_OUTPUT_12);
am_hal_gpio_pinconfig(AM_BSP_GPIO_LED_BLUE, g_AM_HAL_GPIO_OUTPUT_12);
am_hal_gpio_pinconfig(AM_BSP_GPIO_LED_GREEN, g_AM_HAL_GPIO_OUTPUT_12);
am_hal_gpio_pinconfig(AM_BSP_GPIO_LED_YELLOW, g_AM_HAL_GPIO_OUTPUT_12);
// Ensure all pins are cleared
am_hal_gpio_output_clear(AM_BSP_GPIO_LED_RED);
am_hal_gpio_output_clear(AM_BSP_GPIO_LED_BLUE);
am_hal_gpio_output_clear(AM_BSP_GPIO_LED_GREEN);
am_hal_gpio_output_clear(AM_BSP_GPIO_LED_YELLOW);
is_initialized = true;
}
static int count = 0;
// Toggle the red LED every time an inference is performed.
++count;
if (count & 1) {
am_hal_gpio_output_set(AM_BSP_GPIO_LED_RED);
} else {
am_hal_gpio_output_clear(AM_BSP_GPIO_LED_RED);
}
if (is_new_command) {
// Clear the last three LEDs
am_hal_gpio_output_clear(AM_BSP_GPIO_LED_BLUE);
am_hal_gpio_output_clear(AM_BSP_GPIO_LED_GREEN);
am_hal_gpio_output_clear(AM_BSP_GPIO_LED_YELLOW);
error_reporter->Report("Heard %s (%d) @%dms", found_command, score,
current_time);
// Only indicate a 'yes'
if (found_command[0] == 'y') {
// Always light the blue LED
am_hal_gpio_output_set(AM_BSP_GPIO_LED_BLUE);
// Light the other LEDs depending on score
if (score >= 205) {
am_hal_gpio_output_set(AM_BSP_GPIO_LED_GREEN);
}
if(score >= 210) {
am_hal_gpio_output_set(AM_BSP_GPIO_LED_YELLOW);
}
}
}
}
หากตรวจพบคำสั่งใหม่ is_new_command จะเป็นจริง เราจะดับไฟ LED สีน้ำเงิน เขียว และเหลือง จากนั้นจะเปิดไฟอีกครั้งตามค่าของ found_command และ score
สร้างใหม่และแฟลช
เมื่อทำการเปลี่ยนแปลงโค้ดแล้ว ให้ทดสอบโดยทำตามขั้นตอนทั้งหมดจากสร้างและเตรียมไบนารี
10. ขั้นตอนถัดไป
ยินดีด้วย คุณสร้างเครื่องตรวจจับคำพูดเครื่องแรกบนไมโครคอนโทรลเลอร์ได้สำเร็จแล้ว
เราหวังว่าคุณจะสนุกกับข้อมูลเบื้องต้นเกี่ยวกับการพัฒนาด้วย TensorFlow Lite for Microcontrollers แนวคิดเรื่องดีปเลิร์นนิงในไมโครคอนโทรลเลอร์เป็นเรื่องใหม่และน่าตื่นเต้น เราจึงขอแนะนำให้คุณออกไปทดลองใช้
เอกสารอ้างอิง
- ฝึกโมเดลของคุณเองให้เข้าใจคำสั่งต่างๆ หลังจากที่คุณมีประสบการณ์ในการทำงานกับโปรแกรมพื้นฐานแล้ว หมายเหตุ: การฝึกจะใช้เวลา 2-3 ชั่วโมง
- ดูข้อมูลเพิ่มเติมเกี่ยวกับ TensorFlow Lite for Microcontrollers ( เว็บไซต์, GitHub)
- ลองใช้ตัวอย่างอื่นๆ และลองเรียกใช้ใน SparkFun Edge หากรองรับ
- โปรดดูหนังสือของ O'Reilly เรื่อง TinyML: Machine Learning with TensorFlow on Arduino and Ultra-Low Power Micro-Controllers ซึ่งแนะนำแมชชีนเลิร์นนิงในอุปกรณ์ขนาดเล็กและอธิบายโปรเจ็กต์สนุกๆ หลายอย่าง Codelab นี้อิงตามบทที่ 7 และ 8 ของหนังสือ
ขอขอบคุณและขอให้สนุกกับการสร้างสรรค์