บทเรียน Innovedex2025

AI for Robot Decision Making

บทนำ

ในยุคที่ ปัญญาประดิษฐ์ (Artificial Intelligence: AI) กำลังเปลี่ยนแปลงทุกอุตสาหกรรม การทำให้หุ่นยนต์ "มองเห็น" และ "ตัดสินใจตอบสนองทางกายภาพ" กลายเป็นทักษะพื้นฐานที่นักพัฒนายุคใหม่ต้องมี ไม่ว่าจะเป็นในงานด้านอุตสาหกรรม การศึกษา การแพทย์ หรือแม้กระทั่งงานสร้างสรรค์

Workshop นี้ออกแบบมาเพื่อให้ผู้เรียนได้เข้าใจ “ที่มาที่ไป” ของระบบที่ผสานระหว่าง การประมวลผลภาพ (AI-Computer Vision), การสื่อสารระหว่างหน่วยประมวลผล (Inter-Process Communication), และการควบคุมอุปกรณ์ฮาร์ดแวร์ (Hardware Control) อย่างเป็นระบบ

⚠️ ก่อนเริ่มเนื้อหา โปรดศึกษา ภาคผนวก ที่ Section ล่างสุด ก่อนนะครับ !!!

บทที่ 1 การติดตั้ง venv และไลบรารีที่เกี่ยวข้อง

ทำไมเราต้องติดตั้งไลบรารี (Library) เพิ่ม?

ในการเขียนโปรแกรม Python สำหรับงานหุ่นยนต์ เราไม่สามารถใช้แค่ Python เปล่า ๆ ได้ เพราะฟังก์ชันหลายอย่างที่เกี่ยวกับ AI, กล้อง, การควบคุมอุปกรณ์ หรือการสื่อสารแบบเรียลไทม์ ไม่ได้มีอยู่ใน Python มาตรฐาน เราจึงต้อง “ติดตั้งไลบรารีเสริม” (External Libraries) เพิ่มเข้ามา

ไลบรารี (Library) = ชุดคำสั่งเสริมที่คนอื่นเขียนไว้แล้ว เราสามารถนำมาใช้ได้ทันที เช่น ไลบรารีสำหรับอ่านกล้อง, วิเคราะห์ภาพ, ควบคุม Arduino ฯลฯ

ทำไมต้องใช้ venv?

ในการเขียนโปรแกรมหลายๆ Project พร้อมกัน บางครั้งไลบรารีที่ใช้ มีเวอร์ชัน (version) ต่างกัน หากติดตั้งทุกอย่างรวมกันไว้บนเครื่อง จะเกิดปัญหาไลบรารีชนกันได้ ดังนั้นเราจึงใช้เครื่องมือชื่อว่า venv หรือ Virtual Environment แปลว่า “สภาพแวดล้อมจำลอง” ที่ติดตั้งไลบรารีแยกกันอย่างอิสระ

บทที่ 2 การสร้าง Dataset สำหรับตรวจจับวัตถุด้วย Roboflow

Object Detection คืออะไร?

การตรวจจับวัตถุ (Object Detection) คือ กระบวนการที่คอมพิวเตอร์สามารถมองภาพแล้วรู้ว่า มีวัตถุอะไรอยู่ตรงไหนบ้าง ต่างจากการจำแนกรูปภาพ (Image Classification) ที่แค่บอกว่า "ภาพนี้คืออะไร?" Object Detection จะตอบว่า "ภาพนี้มีอะไรบ้าง? และอยู่ตำแหน่งไหน?"

ตัวอย่างคำตอบของ Object Detection:

เจอ โทรศัพท์มือถือ ที่ตำแหน่ง (x1, y1) → (x2, y2)
เจอ ถุงมือ ข้างซ้ายของภาพ
เจอ บอร์ดอิเล็กทรอนิกส์ (board_shield) ใกล้กึ่งกลางภาพ

การเตรียมภาพให้พร้อมสำหรับสอน AI

ก่อนที่ระบบ AI จะรู้วัตถุใด ๆ ได้ เราต้องสอนให้มันรู้จักก่อน โดยการใช้ภาพถ่ายที่มีวัตถุที่เราสนใจ แล้ว “วาดกรอบ” รอบวัตถุนั้นพร้อมใส่ชื่อ (เรียกว่า การทำป้ายกำกับ หรือ labeling) เพื่อบอกให้ AI รู้ว่ากรอบนี้คือวัตถุอะไร การเตรียมภาพที่ดี ควรเลือกภาพที่มีความหลากหลาย เช่น วัตถุที่อยู่ในมุมกล้องต่างกัน มีแสงมาก–น้อยแตกต่างกัน วางอยู่ในตำแหน่งไม่ซ้ำเดิม หรืออยู่กับพื้นหลังหลายแบบ สิ่งเหล่านี้ช่วยให้ AI เข้าใจวัตถุได้ลึกซึ้งขึ้น ไม่ยึดติดกับภาพซ้ำ ๆ

การใช้ Roboflow เพื่อจัดการ Dataset

Roboflow คือแพลตฟอร์มออนไลน์ที่ช่วยให้เราสามารถ อัปโหลดภาพ, วาดกรอบกำกับวัตถุ (Labeling), แบ่งชุดข้อมูล, ตลอดจนดาวน์โหลดเป็นไฟล์ที่พร้อมใช้งานกับ YOLOv8

หลังจากเราเตรียมภาพไว้แล้ว ขั้นตอนต่อไปคือการจัดระเบียบข้อมูลเหล่านั้นให้เป็น "ชุดข้อมูลสำหรับฝึก AI" (Dataset) โดย Roboflow คือเครื่องมือออนไลน์ยอดนิยมที่ช่วยให้เราสามารถทำทุกขั้นตอนได้ง่าย รวดเร็ว และฟรี (ภายใต้โควตาการใช้งานพื้นฐาน)

การวาดกรอบใน Roboflow ใช้งานง่ายมาก เพียงคลิกภาพที่ต้องการ แล้วใช้เมาส์ลากกรอบรอบวัตถุ จากนั้นใส่ชื่อ label ลงไป ระบบจะบันทึกไว้ทันที ทำซ้ำจนกว่าทุกภาพจะมีป้ายกำกับครบเมื่อ labeling เสร็จแล้ว Roboflow จะเสนอให้เราทำการ “Generate Dataset” ซึ่งในขั้นตอนนี้ ระบบจะแบ่งข้อมูลออกเป็น 3 ส่วน คือ

Train set (ชุดฝึก): ใช้สำหรับให้ AI เรียนรู้
Validation set (ชุดตรวจสอบ): ใช้ตรวจสอบความแม่นยำระหว่างการฝึก
Test set (ชุดทดสอบ): ใช้ประเมินผลสุดท้าย

Roboflow จะตั้งค่าสัดส่วนโดยอัตโนมัติ (เช่น 70/20/10) แต่เราสามารถปรับได้เองตามต้องการ จากนั้นสามารถดาวน์โหลด dataset โดยเลือกรูปแบบที่เข้ากับโปรแกรม YOLOv8 ซึ่งก็คือ “YOLOv8 Format” ภายใน Dataset ที่ได้ จะมีโฟลเดอร์ train/valid/test พร้อมทั้งไฟล์ data.yaml ที่เป็นเสมือนสมุดบันทึกของชุดข้อมูลนั้น ซึ่งใช้เชื่อมกับโมเดล AI ในขั้นตอนการ ฝึก (Training)

บทที่ 3 การฝึกโมเดล YOLOv8 บน Google Colab และการนำมาใช้บนเครื่อง

YOLOv8 คืออะไร?

YOLO ย่อมาจาก You Only Look Once เป็นเทคโนโลยี การตรวจจับวัตถุ (Object Detection) ที่มีชื่อเสียงมาก เพราะทำงานได้รวดเร็วและแม่นยำ โดยสามารถ “มองภาพเพียงครั้งเดียว” แล้วรู้ว่าในภาพนั้นมีวัตถุอะไรบ้าง อยู่ตรงไหน ทั้งนี้ YOLOv8 คือรุ่นล่าสุด ที่พัฒนาโดยบริษัท Ultralytics

รู้จัก Ultralytics และ OpenCV

Ultralytics: คือไลบรารี Python ที่เป็นตัวควบคุม YOLOv8 โดยตรง เราสามารถฝึก (train), ตรวจสอบ (validate), ทดสอบ (test) และใช้งาน (inference) ได้ด้วยคำสั่งสั้น ๆ เช่น model.train()
OpenCV (Open Source Computer Vision Library): เป็นไลบรารีสำหรับจัดการภาพ เช่น เปิดภาพจากกล้อง, วาดกรอบ, แปลงสี ฯลฯ ซึ่งเราใช้ร่วมกับ YOLO เพื่อแสดงผลการตรวจจับวัตถุแบบ real-time

ในโลกของปัญญาประดิษฐ์ที่ใช้ในการตรวจจับวัตถุ ไม่ใช่โมเดลเดียวจะเหมาะกับทุกงาน เพราะแต่ละงานมีข้อจำกัดต่างกัน เช่น บางงานต้องการความเร็วมากที่สุด ขณะที่บางงานต้องการความแม่นยำสูงที่สุด ดังนั้นผู้พัฒนา Ultralytics จึงออกแบบโมเดล YOLOv8 ให้มีหลาย “ขนาด” ให้เลือกใช้ตามความเหมาะสม โดยใช้ชื่อย่อเป็นตัวอักษรต่าง ๆ เช่น n, s, m, l, และ x

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

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

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

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

สุดท้ายคือ YOLOv8x (extra large) ซึ่งเป็นโมเดลขนาดใหญ่ที่สุด มีความแม่นยำสูงที่สุดในตระกูล YOLOv8 ถูกออกแบบมาสำหรับงานขั้นสูง เช่น การวิเคราะห์ภาพทางการแพทย์ งานด้านยานยนต์ไร้คนขับ หรือระบบรักษาความปลอดภัยอัจฉริยะ โมเดลนี้เหมาะสำหรับการทำงานในระบบ Cloud หรือ Server ที่มีประสิทธิภาพสูง เพราะใช้พลังประมวลผลมากกว่าทุกรุ่น

บทที่ 4 การสื่อสารระหว่างโปรแกรมด้วย PyZMQ

ทำไมต้องมี “การสื่อสารระหว่างโปรแกรม”?

ในระบบ AI–หุ่นยนต์ที่ซับซ้อน เรามักแยกหน้าที่ของแต่ละส่วนออกเป็นโปรแกรมคนละตัว เช่น

โปรแกรมที่ 1: ใช้กล้องเพื่อวิเคราะห์ภาพ และตรวจจับวัตถุ
โปรแกรมที่ 2: รับข้อมูลจากโปรแกรมที่ 1 แล้วควบคุมเซอร์โวมอเตอร์ให้หมุนไปยังวัตถุนั้น

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

นี่คือสิ่งที่เรียกว่า การสื่อสารระหว่างโปรแกรม (Inter-Process Communication: IPC)

พื้นฐาน TCP/IP และการส่งข้อมูล

การที่โปรแกรมหนึ่งต้องการส่งข้อมูลไปหาอีกโปรแกรมหนึ่ง ไม่ว่าจะอยู่ในคอมพิวเตอร์เครื่องเดียวกันหรืออยู่คนละเครื่อง จำเป็นต้องอาศัย “ช่องทางการสื่อสาร” ซึ่งในโลกของเครือข่ายคอมพิวเตอร์ ช่องทางนี้เรียกว่า โปรโตคอล TCP/IP (Transmission Control Protocol / Internet Protocol)

TCP/IP เปรียบได้กับ ถนนและไปรษณีย์ ที่โปรแกรมต่าง ๆ ใช้ส่ง "จดหมายข้อมูล" ถึงกัน:

IP Address คือ ที่อยู่ปลายทาง (เหมือนบ้านเลขที่ของคอมพิวเตอร์)
Port คือ ช่องรับจดหมายเฉพาะงาน (เช่น Port 80 สำหรับเว็บ, Port 5555 สำหรับงานของเรา)
TCP คือ วิธีส่งจดหมายที่เชื่อถือได้ เช่น บอกว่ามีทั้งหมดกี่แผ่น ส่งครบไหม ข้อมูลเรียงลำดับหรือเปล่า

ในระบบจริง การเขียนโค้ดเพื่อให้ 2 โปรแกรม “เชื่อม TCP กันโดยตรง” ต้องมีขั้นตอนยุ่งยาก เช่น:

เปิด socket
รอการเชื่อมต่อ (bind + listen)
รับข้อมูลแบบไบต์ (byte stream)
แปลงไบต์เป็นข้อความ
ตรวจสอบว่าเชื่อมต่อหลุดหรือไม่

นี่คือเหตุผลที่ ZeroMQ (ZMQ) ถูกพัฒนาขึ้นมาเพื่อ "ซ่อนความซับซ้อนของ TCP" เหล่านี้ไว้เบื้องหลัง แล้วให้เราเขียนแค่โค้ดที่ง่ายเหมือน “ส่งข้อความในห้องแชท”

ZeroMQ (ZMQ) คืออะไร?

ZeroMQ หรือเรียกสั้น ๆ ว่า ZMQ เป็นเครื่องมือ (Messaging Library) ที่ถูกออกแบบมาเพื่อให้การสื่อสารระหว่างโปรแกรมนั้น "ง่ายขึ้นมาก" โดยซ่อนรายละเอียดของ TCP ไว้เบื้องหลัง และเปิดให้เราใช้รูปแบบที่เรียบง่าย เช่น:

PUB/SUB (Publisher / Subscriber): รูปแบบที่ผู้ส่งหนึ่งคน (Publisher) ส่งข้อความไปให้ผู้รับหลายคน (Subscribers)
REQ/REP (Request / Reply): การถาม–ตอบระหว่างสองโปรแกรม

PyZMQ คืออะไร?

ZMQ เขียนด้วยภาษา C++ แต่ในระบบของเรา เราใช้ภาษา Python ดังนั้นจึงต้องมีตัวกลางที่เชื่อมระหว่าง Python กับ ZMQ นั่นก็คือไลบรารีชื่อว่า PyZMQ ที่รองรับ รูปแบบ Publisher / Subscriber (PUB/SUB) ลองนึกภาพง่าย ๆ ว่าโปรแกรมหนึ่งทำหน้าที่เป็น ผู้กระจายเสียง (Publisher) ส่วนอีกโปรแกรมหนึ่งเป็น ผู้ฟัง (Subscriber)

Publisher จะส่งข้อมูลออกมาเรื่อย ๆ
Subscriber จะรอฟังเฉพาะ "หัวข้อ (Topic)" ที่ต้องการ

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

บทที่ 5 การคุวบคุม Arduino ด้วย PyFirmata2

ทำไมต้องใช้ Arduino?

Arduino เป็นบอร์ดอิเล็กทรอนิกส์ขนาดเล็กที่สามารถเชื่อมต่อกับอุปกรณ์ต่าง ๆ เช่น เซนเซอร์, มอเตอร์, หลอดไฟ ฯลฯ ได้อย่างง่ายดาย มันถูกออกแบบให้ใช้งานง่าย โดยเฉพาะสำหรับนักเรียน นักศึกษา และผู้เริ่มต้น เราสามารถสั่ง Arduino ให้ “หมุนมอเตอร์” หรือ “เปิดไฟ” ได้ ผ่านโค้ดภาษา C ที่เขียนใน Arduino IDE แต่ในระบบของเรานั้น เราใช้ภาษา Python เป็นหลัก และต้องการให้ Python ควบคุม Arduino โดยตรง จึงต้องมีตัวช่วย อย่าง Firmata ที่เป็นกลไกการสื่อสารอย่างหนึ่งในรูปแบบ Serial

การสื่อสารผ่านพอร์ต Serial (Serial Communication)

เมื่อเราต่อสาย USB จากคอมพิวเตอร์ไปยังบอร์ด Arduino สิ่งที่เกิดขึ้นจริง ๆ ก็คือการสร้าง "ช่องทาง" ในการส่งข้อมูลจากเครื่องหนึ่งไปยังอีกเครื่องหนึ่งผ่านสายไฟ ช่องทางนี้เรียกว่า Serial Communication หรือ "การสื่อสารแบบอนุกรม" คำว่า อนุกรม (serial) แปลว่า "ทีละตัว" หรือ "เรียงกันเป็นลำดับ" คือการส่งข้อมูลทีละบิต (bit) เช่น "10101101 → Arduino"

ในระบบคอมพิวเตอร์ทั่วไป การส่งข้อมูลนั้นสามารถเป็นแบบ ขนาน (parallel) คือส่งหลายบิตพร้อมกันหลายเส้นทาง แต่ Arduino และอุปกรณ์ฝังตัวส่วนใหญ่ใช้แบบ “อนุกรม” เพราะ ใช้สายสื่อสารน้อย (แค่ 2 เส้น: TX ส่ง, RX รับ) ทั้งนี้ในเชิงเทคนิค ข้อมูลจะถูกแปลงเป็นไฟฟ้า: 0 → ไฟต่ำ, 1 → ไฟสูง โดย Arduino จะฟังสัญญาณไฟนี้ทีละบิตผ่านขา RXส่วนคอมพิวเตอร์ก็จะส่งข้อมูลผ่านขา TX ผ่านสาย USB

Arduino ฟังภาษาอะไร? ทำไมต้องใช้ Firmata?

คำถามสำคัญคือ: เมื่อคอมพิวเตอร์ส่งข้อมูล 1s และ 0s ไปยัง Arduino แล้ว Arduino เข้าใจได้อย่างไร?
คำตอบคือ: โดยปกติ Arduino ไม่เข้าใจสิ่งที่ส่งมาจาก Python

เพราะ:

Arduino ถูกออกแบบให้รันโค้ด C++ ที่ถูกอัปโหลดเข้าไปไว้ล่วงหน้า
เมื่อเปิดเครื่อง มันจะเริ่มรันโค้ดนั้นทันที — มันไม่ได้รอฟังคำสั่งใหม่ ๆ จาก USB

แต่ในบางกรณี เราต้องการให้ คอมพิวเตอร์เป็นผู้ตัดสินใจหลัก เช่น การวิเคราะห์ภาพ ตรวจจับวัตถุ คำนวณตำแหน่ง แล้วสั่งให้ Arduino “กระทำบางอย่าง” ตามที่ระบบ AI คิดมาให้ เช่น หมุนเซอร์โวไปยังตำแหน่งที่เหมาะสม นั่นหมายความว่าเราต้องการให้ Arduino เป็นเหมือน "หุ่นเชิด" หรือ "ผู้ปฏิบัติงาน" ที่สามารถฟังคำสั่งจากภายนอกได้แบบเรียลไทม์ โดยไม่ต้องอัปโหลดโค้ดใหม่ทุกครั้งที่เปลี่ยนคำสั่ง

Firmata คืออะไร และมันทำงานอย่างไร?

Firmata คือโปรแกรมที่ฝังอยู่ใน Arduino ทำหน้าที่คล้าย "ล่าม" ที่แปลภาษาจากคอมพิวเตอร์ให้ Arduino เข้าใจ หรืออีกมุมหนึ่ง มันคือ มาตรฐานการสื่อสารระหว่างซอฟต์แวร์กับฮาร์ดแวร์ Arduino ผ่าน Serial ซึ่ง Firmaware ที่เป็นที่นิยมของ มาตรฐาน Firmata คือ StandardFirmata ที่เบื้องหลังการทำงานเรียบง่ายแต่มหัศจรรย์

เมื่อเราอัปโหลดโปรแกรมนี้ลงไปในบอร์ด Arduino แล้ว ตัวบอร์ดจะหยุดการทำงานแบบรันลูปอิสระ แล้ว "รอฟังคำสั่งจาก Serial Port" ตลอดเวลา หมายความว่า Arduino จะทำหน้าที่เหมือน "เครื่องรับคำสั่งอัตโนมัติ" ที่นั่งนิ่ง ๆ และไม่ทำอะไรเลย จนกว่าจะมีคำสั่งส่งเข้ามาทางสาย USB

คำสั่งที่ส่งมานั้นไม่ได้มาเป็นคำว่า "หมุนเซอร์โวไปที่ 90 องศา" แบบเป็นตัวอักษร แต่จะถูกส่งมาเป็น "รหัสไบต์" (byte-level commands) ซึ่งใช้ภาษาพิเศษที่เรียกว่า Firmata Protocol เป็นภาษากลางระหว่าง Python และ Arduino

ตัวอย่างเช่น หาก Python ต้องการหมุนเซอร์โวไปที่ 90 องศา มันจะไม่ส่งคำว่า 90 ไปตรง ๆ แต่มันจะส่งรหัสเช่น [SET_PIN_MODE, 9, SERVO_MODE] แล้วตามด้วย [ANALOG_MESSAGE, 9, 90]

เมื่อ StandardFirmata รับข้อมูลเหล่านี้ มันจะรู้ทันทีว่า "คำสั่งนี้คือการสั่งให้ขา D9 ทำหน้าที่เป็นเซอร์โว แล้วหมุนไปที่ 90 องศา" แล้วจึงทำตามคำสั่งนั้นทันที สิ่งที่น่าทึ่งคือ ทุกอย่างนี้เกิดขึ้นในระดับไบต์ และมีความเร็วสูงมาก จึงทำให้การควบคุมจาก Python ดูเหมือนว่าเรากำลัง "รันโค้ดบน Arduino" ทั้งที่จริงแล้ว บอร์ดแค่ทำตามที่ Python สั่งผ่าน Serial เท่านั้น

บทที่ 6 สรุปรวบยอด

การเรียนรู้ทั้ง 5 บทเรียนที่ผ่านมา เปรียบได้กับการเตรียมเครื่องมือ, วางแผนการสร้าง และฝึกทักษะเฉพาะด้าน และตอนนี้ ถึงเวลาที่จะ "ประกอบทุกชิ้นส่วนเข้าด้วยกัน" เพื่อสร้างระบบจริงที่เห็นผลได้ชัดเจน นั่นคือ: Final Project: ระบบตรวจจับวัตถุและควบคุมเซอร์โวมอเตอร์แบบ Real-Time ระบบนี้จะทำให้คอมพิวเตอร์ของเราสามารถ:

เปิดกล้อง → ตรวจจับวัตถุ (เช่น board_shield)
คำนวณตำแหน่งวัตถุในภาพ (center-x)
ส่งข้อมูลผ่าน ZMQ ไปยัง Node2
แปลงตำแหน่งเป็นองศา 0–180
สั่ง Arduino หมุนเซอร์โวให้ชี้ไปยังวัตถุที่ตรวจจับได้

ภาคผนวก

การติดตั้ง Python

https://youtu.be/j87HxNLRHWM

การติดตั้ง Visual Studio Code

https://youtu.be/0B0LSuiGVi8

Vision: Detect object from webcam

https://github.com/chacharin/learn_python_yolo

Communication: Transfer data

https://github.com/chacharin/learn_pyzmq

Action: Control servo motor on Arduino board

https://github.com/chacharin/learn_pyfirmata2