AI Speech Recognition พร้อม TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์และ SparkFun Edge

สิ่งที่คุณจะสร้าง

ใน codelab นี้เราจะได้เรียนรู้การใช้ TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์ เพื่อเรียกใช้โมเดลการเรียนรู้เชิงลึกบน SparkFun Edge Development Board เราจะทำงานร่วมกับรูปแบบการตรวจจับเสียงพูดในตัวของบอร์ดซึ่งใช้โครงข่ายประสาทเทียมเพื่อตรวจจับคำว่า "ใช่" และ "ไม่" ที่พูดผ่านไมโครโฟนสองตัวของบอร์ด

bf256d403a1821af.gif

การเรียนรู้ของเครื่องเกี่ยวกับไมโครคอนโทรลเลอร์

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

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

1360b61fbfa33657.jpeg

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

TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์ (ซอฟต์แวร์)

358ffdb9eb758b90.png

TensorFlow เป็นเฟรมเวิร์กการเรียนรู้ของเครื่องโอเพนซอร์สของ Google สำหรับการฝึกอบรมและการรันโมเดล TensorFlow Lite เป็นซอฟต์แวร์เฟรมเวิร์กซึ่งเป็นเวอร์ชันที่ปรับให้เหมาะสมของ TensorFlow ซึ่งมีเป้าหมายเพื่อเรียกใช้แบบจำลองเทนเซอร์โฟลว์บนอุปกรณ์ขนาดเล็กที่ใช้พลังงานค่อนข้างต่ำเช่นโทรศัพท์มือถือ

TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์ เป็นซอฟต์แวร์เฟรมเวิร์กซึ่งเป็นเวอร์ชันที่ปรับให้เหมาะสมของ TensorFlow ซึ่งมีเป้าหมายเพื่อเรียกใช้แบบจำลองเทนเซอร์โฟลว์บนฮาร์ดแวร์ขนาดเล็กที่ใช้พลังงานต่ำเช่นไมโครคอนโทรลเลอร์ เป็นไปตามข้อ จำกัด ที่จำเป็นในสภาพแวดล้อมที่ฝังตัวเหล่านี้กล่าวคือมีขนาดไบนารีที่เล็กไม่ต้องการการสนับสนุนระบบปฏิบัติการไลบรารี C หรือ C ++ มาตรฐานใด ๆ หรือการจัดสรรหน่วยความจำแบบไดนามิกเป็นต้น

SparkFun Edge (ฮาร์ดแวร์)

SparkFun Edge เป็นแพลตฟอร์มที่ใช้ไมโครคอนโทรลเลอร์: คอมพิวเตอร์ขนาดเล็กบนแผงวงจรเดียว มีโปรเซสเซอร์หน่วยความจำและฮาร์ดแวร์ I / O ที่ช่วยให้สามารถส่งและรับสัญญาณดิจิทัลไปยังอุปกรณ์อื่น ๆ มีไฟ LED ที่ควบคุมซอฟต์แวร์ได้สี่ดวงในสี Google ที่คุณชื่นชอบ

aa4493835a2338c6.png

ไมโครคอนโทรลเลอร์จะไม่เรียกใช้ระบบปฏิบัติการต่างจากคอมพิวเตอร์ แต่โปรแกรมที่คุณเขียนจะทำงานบนฮาร์ดแวร์โดยตรง คุณเขียนโค้ดของคุณบนคอมพิวเตอร์และดาวน์โหลดไปยังไมโครคอนโทรลเลอร์ผ่านอุปกรณ์ที่เรียกว่าโปรแกรมเมอร์

ไมโครคอนโทรลเลอร์ไม่ใช่คอมพิวเตอร์ที่มีประสิทธิภาพ มีโปรเซสเซอร์ขนาดเล็กและมีหน่วยความจำไม่มากนัก แต่เนื่องจากได้รับการออกแบบให้เรียบง่ายที่สุดไมโครคอนโทรลเลอร์จึงใช้พลังงานน้อยมาก ขึ้นอยู่กับว่าโปรแกรมของคุณทำอะไร SparkFun Edge สามารถทำงานได้หลายสัปดาห์โดยใช้แบตเตอรี่เซลล์แบบเหรียญเดียว!

สิ่งที่คุณจะได้เรียนรู้

  • รวบรวมโปรแกรมตัวอย่างสำหรับ SparkFun Edge บนคอมพิวเตอร์ของคุณ
  • ปรับใช้โปรแกรมกับอุปกรณ์ของคุณ
  • ทำการเปลี่ยนแปลงโปรแกรมและปรับใช้อีกครั้ง

สิ่งที่คุณต้องการ

คุณจะต้องใช้ฮาร์ดแวร์ต่อไปนี้:

คุณจะต้องมีซอฟต์แวร์ต่อไปนี้:

  • Git (ตรวจสอบว่าติดตั้งหรือไม่โดยเรียกใช้ git บนบรรทัดคำสั่ง)
  • Python 3 (ตรวจสอบว่าติดตั้งหรือไม่โดยเรียกใช้ python3 หรือ python --version python3 บนบรรทัดคำสั่ง)
  • Pip สำหรับ Python 3 ( คำตอบ StackOverflow ที่เป็นประโยชน์ )
  • ทำให้ 4.2.1 ขึ้นไป (ตรวจสอบว่าติดตั้งหรือไม่โดยเรียกใช้ make --version ในบรรทัดคำสั่ง)
  • ไดรเวอร์ SparkFun Serial Basic

ไมโครคอนโทรลเลอร์ SparkFun Edge มาพร้อมกับไบนารีที่ติดตั้งไว้ล่วงหน้าซึ่งสามารถเรียกใช้รูปแบบเสียงพูดได้ ก่อนที่เราจะเขียนทับสิ่งนี้ด้วยเวอร์ชันของเราเองให้เรียกใช้โมเดลนี้ก่อน

เพิ่มพลังให้บอร์ดของคุณโดย:

  1. การใส่แบตเตอรี่เซลล์แบบเหรียญลงในขั้วต่อแบตเตอรี่ที่ด้านหลังของบอร์ด (โดยให้ด้าน "+" ของแบตเตอรี่หงายขึ้นหากบอร์ดของคุณมาพร้อมกับแบตเตอรี่ที่ใส่อยู่แล้วให้ดึงแถบพลาสติกออกแล้วดันแบตเตอรี่เพื่อ มันแทรกจนสุด)

25a6cc6b208e8a4e.png

  1. หากคุณไม่มีแบตเตอรี่แบบเหรียญคุณสามารถใช้อุปกรณ์โปรแกรมเมอร์ SparkFun USB-C Serial Basic เพื่อจ่ายไฟให้กับบอร์ดได้ ในการต่ออุปกรณ์นี้เข้ากับบอร์ดของคุณให้ทำตามขั้นตอนต่อไปนี้:
  • ค้นหาส่วนหัวหกพินที่ด้านข้างของ SparkFun Edge
  • เสียบ SparkFun USB-C Serial Basic เข้ากับพินเหล่านี้ตรวจสอบให้แน่ใจว่าหมุดที่มีข้อความ "BLK" และ "GRN" บนอุปกรณ์แต่ละตัวเรียงกันอย่างถูกต้อง
  • เชื่อมต่อสาย USB-C ระหว่าง SparkFun USB-C Serial Basic กับคอมพิวเตอร์ของคุณ

b140822f0019f92a.png

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

โมเดลแมชชีนเลิร์นนิงบนกระดานได้รับการฝึกฝนให้รู้จักคำว่า "ใช่" และ "ไม่ใช่" และตรวจจับการมีและไม่มีเสียงพูด มันสื่อสารผลลัพธ์ด้วยไฟ LED สีสว่าง ตารางต่อไปนี้แสดงความหมายของ LED แต่ละสี:

ผลการตรวจจับ

LED สี

"ใช่"

สีเหลือง

"ไม่"

สีแดง

คำพูดที่ไม่รู้จัก

สีเขียว

ไม่พบคำพูด

ไม่มีไฟ LED ติด

ให้มันลอง

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

  • ถือกระดานประมาณ 10 "จากปากของคุณ
  • หลีกเลี่ยงเสียงรบกวนจากพื้นหลังมากเกินไป
  • ทำซ้ำ "ใช่" หลาย ๆ ครั้งติดต่อกันอย่างรวดเร็ว (ลองพูดว่า "ใช่ใช่ใช่")

ตอนนี้เรากำลังจะดาวน์โหลดติดตั้งและเรียกใช้รูปแบบการพูดบนไมโครคอนโทรลเลอร์เอง สำหรับสิ่งนี้อันดับแรกเราดาวน์โหลดซอร์สโค้ดสำหรับโปรแกรมนี้และการอ้างอิงที่เราต้องสร้างขึ้น โปรแกรมเขียนด้วยภาษา C ++ ซึ่งจะต้องรวบรวมเป็น ไบนารี ก่อนที่จะดาวน์โหลดลงบนบอร์ด ไบนารีเป็นไฟล์ที่มีโปรแกรมในรูปแบบที่สามารถเรียกใช้โดยตรงโดยฮาร์ดแวร์ SparkFun Edge

คำแนะนำต่อไปนี้เขียนขึ้นสำหรับ Linux หรือ MacOS

ดาวน์โหลด TensorFlow repo

รหัสมีอยู่ในที่เก็บ 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

ดาวน์โหลดการอ้างอิง Python

เราจะใช้ Python 3 เพื่อเตรียมไบนารีของเราและแฟลชไปที่อุปกรณ์ สคริปต์ Python ขึ้นอยู่กับไลบรารีที่พร้อมใช้งาน รันคำสั่งต่อไปนี้เพื่อติดตั้งการอ้างอิงเหล่านี้:

pip3 install pycrypto pyserial --user

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

สร้างไบนารี

ในการดาวน์โหลดการอ้างอิงที่จำเป็นทั้งหมดและสร้างไบนารีให้รันคำสั่งต่อไปนี้:

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 ในไดเร็กทอรีที่คุณรันคำสั่ง นี่คือไฟล์ที่เราจะกระพริบไปยังอุปกรณ์

กระพริบคืออะไร?

SparkFun Edge เก็บโปรแกรมที่กำลังทำงานอยู่ในหน่วยความจำแฟลช 512 กิโลไบต์ หากเราต้องการให้บอร์ดรันโปรแกรมใหม่เราต้องส่งไปที่บอร์ดซึ่งจะจัดเก็บไว้ในหน่วยความจำแฟลชเขียนทับโปรแกรมใด ๆ ที่บันทึกไว้ก่อนหน้านี้

กระบวนการนี้เรียกว่า "กระพริบ" และเราจะใช้เพื่อส่งโปรแกรมของเราไปยังบอร์ด

ติดโปรแกรมเมอร์เข้ากับบอร์ด

ในการดาวน์โหลดโปรแกรมใหม่ไปยังบอร์ดเราจะใช้โปรแกรมเมอร์อนุกรม SparkFun USB-C Serial Basic อุปกรณ์นี้ช่วยให้คอมพิวเตอร์ของคุณสื่อสารกับไมโครคอนโทรลเลอร์ผ่าน USB

ในการต่ออุปกรณ์นี้เข้ากับบอร์ดของคุณให้ทำตามขั้นตอนต่อไปนี้:

  1. ค้นหาส่วนหัวหกพินที่ด้านข้างของ SparkFun Edge
  2. เสียบ SparkFun USB-C Serial Basic เข้ากับพินเหล่านี้ตรวจสอบให้แน่ใจว่าหมุดที่มีข้อความ "BLK" และ "GRN" บนอุปกรณ์แต่ละตัวเรียงกันอย่างถูกต้อง

b140822f0019f92a.png

แนบโปรแกรมเมอร์เข้ากับคอมพิวเตอร์ของคุณ

เราจะเชื่อมต่อบอร์ดกับคอมพิวเตอร์ของคุณผ่าน 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

เรียกใช้สคริปต์เพื่อแฟลชบอร์ดของคุณ

ในการแฟลชบอร์ดเราต้องใส่ลงในสถานะ "bootloader" พิเศษที่เตรียมให้รับไบนารีใหม่ จากนั้นเราจะเรียกใช้สคริปต์เพื่อส่งไบนารีไปยังบอร์ด

มาทำความคุ้นเคยกับปุ่มต่อไปนี้บนกระดาน:

64c620570b9d2f83.png

ทำตามขั้นตอนต่อไปนี้เพื่อรีเซ็ตและแฟลชบอร์ด:

  1. ตรวจสอบให้แน่ใจว่าบอร์ดของคุณเชื่อมต่อกับโปรแกรมเมอร์และการตั้งค่าทั้งหมดเชื่อมต่อกับคอมพิวเตอร์ของคุณผ่าน USB
  2. เริ่ม กดปุ่มที่มีเครื่องหมาย 14 บนกระดานค้างไว้ ถือไว้จนถึงขั้นตอนที่ 6
  3. ยังคงกดปุ่มที่มีเครื่องหมาย 14 ค้างไว้เพื่อรีเซ็ตบอร์ดเข้าสู่สถานะ bootloader ให้คลิกปุ่มที่มีเครื่องหมาย RST เพื่อรีเซ็ตบอร์ด
  4. ยังคงกดปุ่มที่มีเครื่องหมาย 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
  1. ยังคงกดปุ่มที่มีเครื่องหมาย 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...]
  1. หยุด กดปุ่มที่มีเครื่องหมาย 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"

ลองใช้โปรแกรม

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

RST เพื่อรีสตาร์ทบอร์ดและเริ่มโปรแกรม หากไฟ LED สีน้ำเงินเริ่มกะพริบแสดงว่ากระพริบสำเร็จ ถ้าไม่ให้เลื่อนลงไปที่ส่วน " จะเกิดอะไรขึ้นถ้าไม่ได้ผล" ส่วนด้านล่าง

bf256d403a1821af.gif

โมเดลแมชชีนเลิร์นนิงบนกระดานได้รับการฝึกฝนให้รู้จักคำว่า "ใช่" และ "ไม่ใช่" และตรวจจับการมีและไม่มีเสียงพูด มันสื่อสารผลลัพธ์ด้วยไฟ LED สีสว่าง ตารางต่อไปนี้แสดงความหมายของ LED แต่ละสี:

ผลการตรวจจับ

LED สี

"ใช่"

สีเหลือง

"ไม่"

สีแดง

คำพูดที่ไม่รู้จัก

สีเขียว

ไม่พบคำพูด

ไม่มีไฟ LED ติด

ให้มันลอง

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

  • ถือกระดานให้ห่างจากปากประมาณ 10 นิ้ว
  • หลีกเลี่ยงเสียงรบกวนจากพื้นหลังมากเกินไป
  • ทำซ้ำ "ใช่" หลาย ๆ ครั้งติดต่อกันอย่างรวดเร็ว (ลองพูดว่า "ใช่ใช่ใช่")

จะเกิดอะไรขึ้นถ้ามันไม่ได้ผล?

นี่คือปัญหาที่อาจเกิดขึ้นและวิธีแก้ไขข้อบกพร่อง:

ปัญหา: หลังจากกะพริบไฟ LED ไม่ติด

วิธีแก้ไข: ลองกดปุ่ม RST หรือถอดและเชื่อมต่อบอร์ดใหม่จากโปรแกรมเมอร์ หากไม่สามารถใช้งานได้ให้ลองกะพริบบอร์ดอีกครั้ง

ปัญหา: ไฟ LED สีน้ำเงินสว่างขึ้น แต่หรี่มาก

วิธีแก้ไข: เปลี่ยนแบตเตอรี่เมื่อแบตเตอรี่ใกล้หมด อีกวิธีหนึ่งคือบอร์ดสามารถใช้พลังงานจากคอมพิวเตอร์โดยใช้โปรแกรมเมอร์และสายเคเบิล

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

เปิดการเชื่อมต่อแบบอนุกรม

ตามค่าเริ่มต้นโค้ดตัวอย่าง 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);

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

ตอนนี้คุณรู้วิธีสร้างและแฟลช 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 สี่ดวง ขณะนี้เรากำลังกะพริบ 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 สี่ดวงลองปรับเปลี่ยนโปรแกรมเพื่อใช้เป็นตัวบ่งชี้ score ของคำสั่งที่กำหนด คะแนนต่ำจะได้รับ LED ที่สว่างเพียงดวงเดียวและคะแนนที่สูงจะส่งผลให้เกิดไฟหลายดวง

เพื่อให้แน่ใจว่าเรามีวิธีที่จะรู้ว่าโปรแกรมกำลังทำงานอยู่เราจะทำให้ไฟ LED สีแดงกระพริบอย่างต่อเนื่องแทนที่จะเป็นสีน้ำเงิน ไฟ LED สีน้ำเงินสีเขียวและสีเหลืองที่อยู่ติดกันจะถูกใช้เพื่อแสดงความแข็งแกร่งของ score ล่าสุดของเรา และเพื่อความเรียบง่ายเราจะสว่างขึ้นก็ต่อเมื่อมีการพูดคำว่า "ใช่" หากตรวจพบคำอื่นไฟ 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

สร้างใหม่และแฟลช

เมื่อคุณทำการเปลี่ยนแปลงโค้ดแล้วให้ทดสอบโดยรันขั้นตอนทั้งหมดจาก Build และเตรียมไบนารี

ขอแสดงความยินดีคุณสร้างเครื่องตรวจจับเสียงพูดเครื่องแรกบนไมโครคอนโทรลเลอร์สำเร็จแล้ว!

เราหวังว่าคุณจะสนุกกับการแนะนำสั้น ๆ เกี่ยวกับการพัฒนาด้วย TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์ แนวคิดของการเรียนรู้เชิงลึกเกี่ยวกับไมโครคอนโทรลเลอร์เป็นเรื่องใหม่และน่าตื่นเต้นและเราขอแนะนำให้คุณออกไปทดลอง!

เอกสารอ้างอิง

  • ฝึกโมเดลของคุณเอง เพื่อทำความเข้าใจคำสั่งต่างๆตอนนี้คุณมีประสบการณ์ในการทำงานกับโปรแกรมพื้นฐานแล้ว หมายเหตุ: การฝึกจะใช้เวลาสองสามชั่วโมง!
  • เรียนรู้เพิ่มเติมเกี่ยวกับ TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์ ( เว็บไซต์ GitHub )
  • ลองใช้ ตัวอย่าง อื่น ๆ และลองรันบน SparkFun Edge หากได้รับการสนับสนุน
  • อ้างอิงจากหนังสือ O'Reilly TinyML: Machine Learning with TensorFlow บน Arduino และ Ultra-Low Power Micro-Controllers ซึ่งแนะนำการเรียนรู้ของเครื่องบนอุปกรณ์ขนาดเล็กและเดินผ่านโครงการสนุก ๆ มากมาย โค้ดแล็บนี้อ้างอิงจากบทที่ 7 และ 8 ของหนังสือ

26699b18f2b199f.png

ขอขอบคุณและขอให้สนุกกับการสร้าง!