รู้จักบอร์ดและอีมูเลเตอร์

หลักสูตร

Explorer: เปิดโลกระบบสมองกลฝังตัว · รู้จักระบบสมองกลฝังตัวและเขียนโปรแกรมแรก

ระดับ

L1 รู้จัก

เวลาโดยประมาณ

25 นาที (แนวคิด 8 · ฝึก 12 · เช็กความเข้าใจ 5)

อุปกรณ์

BENTO Emulator (ไม่ต้องมีบอร์ด) · Eva Kit · Dev Kit

ทักษะที่ฝึก

• การจำลองฮาร์ดแวร์และอีมูเลเตอร์ ถึง L1
• สถาปัตยกรรมคอมพิวเตอร์ ถึง L1

ควรเรียนก่อน

• ระบบสมองกลฝังตัวซ่อนอยู่รอบตัวเรา

สถานะ

ทดลองใช้ (alpha)

• เปิดสไลด์
• เปิด BENTO IDE
• ไฟล์ของบทเรียนบน GitHub

เป้าหมาย

1. เปิด BENTO IDE แล้วรันไฟล์ตัวอย่างใน BENTO Emulator จนเห็นชื่อบอร์ดขึ้นบนจอจำลอง
2. บอกความต่างระหว่าง Eva Kit กับ TESAIoT Dev Kit ได้อย่างน้อย 2 ข้อ
3. อธิบายได้ว่าอะไรที่อีมูเลเตอร์ตอบได้ และอะไรที่ต้องพิสูจน์บนบอร์ดจริง

ก่อนเริ่ม

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

สิ่งที่ต้องมีในบทนี้มีแค่คอมพิวเตอร์ที่เปิดเบราว์เซอร์ Chrome หรือ Edge ได้ (บทเรียนนี้ออกแบบสำหรับจอคอมพิวเตอร์หรือแท็บเล็ต ไม่ใช่มือถือ)

ดูของจริงก่อน

ทำตามนี้ก่อน แล้วค่อยมาอ่านคำอธิบาย

1. เปิด BENTO IDE ที่ https://ide.tesaiot.dev/
2. IDE เปิดมาที่มุมมอง Blocks (ต่อบล็อกแทนการพิมพ์) ให้กดปุ่ม Python ที่หัวจอ เพื่อสลับเป็นมุมมองโค้ด
3. คัดลอกโค้ดทั้งไฟล์จาก examples/01_board_knows_itself.py ไปวางในช่องแก้โค้ด
4. กดปุ่ม BENTO Emulator บนแถบเครื่องมือ แผงอีมูเลเตอร์จะเลื่อนออกมาทางขวา แล้วกด ▶ Run ในแผงนั้น
5. มองที่จอจำลอง คุณควรเห็นชื่อบอร์ดตัวสีฟ้า และบรรทัดบอกว่ามีไฟกี่ดวง ปุ่มกี่ปุ่ม

ถ้าเห็นแล้ว ยินดีด้วย คุณเพิ่งรันโปรแกรมบนไมโครคอนโทรลเลอร์ (จำลอง) เป็นครั้งแรก

ถ้ามีบอร์ดอยู่ในมือ ต่อบอร์ดเข้ากับคอมพิวเตอร์ด้วยสาย USB กด Connect ที่มุมขวาบนของ IDE เลือกพอร์ตของบอร์ด แล้วบนจอบอร์ดให้แตะการ์ด BENTO Playground เปิดค้างไว้ จากนั้นกด Program to Device ผลจะขึ้นบนจอบอร์ดจริง รายชื่อไฟทีละดวงอยู่ในลิ้นชัก Console ซึ่งเปิดได้ด้วยปุ่มสีเขียวมุมขวาล่างของหน้า Playground

แนวคิด

1. บอร์ดสองรุ่นที่ใช้โค้ดชุดเดียวกัน

หลักสูตรใน TESA Open Knowledge ใช้บอร์ดที่มีชิป PSoC™ Edge E84 ของ Infineon อยู่สองรุ่น

	Eva Kit	TESAIoT Dev Kit
ชื่อทางเทคนิค	KIT_PSE84_EVAL_EPC2	SoM KIT_PSE84_AI บนบอร์ดฐาน QWA309
หลอด LED ที่ Python สั่งได้	3 ดวง	5 ดวง
เซนเซอร์เพิ่มเติม		วัดอุณหภูมิและความชื้น (SHT40) ความกดอากาศ (DPS368) และเรดาร์
จอ	จอสัมผัส 800 x 480 จุด	จอสัมผัส 800 x 480 จุด

ข้อมูลในตารางนี้มาจากหลักสูตร AIoT in Action ซึ่งใช้บอร์ดทั้งสองรุ่น

ตัวอย่างในบทนี้ไม่ได้จำว่าบอร์ดมีไฟกี่ดวง มันถาม gpio.board_info() ซึ่งคืนข้อมูลก้อนหนึ่ง (dict) ที่มีชื่อบอร์ด จำนวนไฟ และรายชื่อไฟ เพราะแบบนี้ โค้ดชุดเดียวจึงรันได้บนทั้งสองบอร์ด และในอีมูเลเตอร์ด้วย

ชิป PSoC Edge E84 มีหน่วยประมวลผลมากกว่าหนึ่งคอร์ เฟิร์มแวร์ BENTO แบ่งงานให้คอร์ช่วยกัน เช่น คอร์หนึ่งรันโปรแกรม MicroPython ของเรา อีกคอร์ดูแลจอและหน้าจอสัมผัส ตอนนี้แค่รู้ไว้ก่อน ว่าทำไมบางคำสั่งต้องรอให้ “อีกฝั่ง” ทำงานเสร็จ

2. MicroPython

โปรแกรมที่เราเขียนเป็นภาษา MicroPython คือภาษา Python ฉบับที่ทำให้เล็กพอจะรันบนไมโครคอนโทรลเลอร์ได้ ไม่ต้องคอมไพล์ กดรันแล้วเห็นผลเลย เหมาะกับการเริ่มต้น ส่วนงานระดับมืออาชีพที่ต้องรีดความเร็วหรือพลังงาน จะใช้ภาษา C ซึ่งมีหลักสูตรแยกต่างหาก

บอร์ดเหล่านี้มีโมดูลของ BENTO เองที่ใช้บ่อยในหลักสูตรนี้ ได้แก่ ui (วาดบนจอ) lcd (ลิ้นชัก Console) gpio (ไฟและปุ่ม) sensors (เซนเซอร์) wifi และ mqtt (เครือข่าย)

3. อีมูเลเตอร์ตอบอะไรได้ และอะไรที่ตอบไม่ได้

BENTO Emulator รันโปรแกรม MicroPython ของเราในเบราว์เซอร์ และวาดจอขนาดเท่าจอบอร์ด ปุ่ม HW ในแผงอีมูเลเตอร์เปิดแผงฮาร์ดแวร์จำลอง ที่มีหลอดไฟ ปุ่ม ลูกบิด และแผ่นเอียง ให้เราลองโปรแกรมได้โดยไม่ต้องมีบอร์ด

อีมูเลเตอร์ตอบคำถาม “โปรแกรมรันจบไหม มีข้อผิดพลาดไหม และหน้าจอออกมาหน้าตาแบบไหน” ได้ดีมาก แต่มันไม่ใช่บอร์ดจริง ค่าเซนเซอร์เป็นค่าจำลอง WiFi เป็นของจำลอง และเรื่องจังหวะเวลาหรือข้อจำกัดของฮาร์ดแวร์บางอย่างไม่มีทางโผล่ในเบราว์เซอร์ หลักคิดที่เราใช้ตลอดหลักสูตรคือ ใช้อีมูเลเตอร์เรียนแนวคิด ใช้บอร์ดจริงพิสูจน์และวัดผล

ตัวอย่างสมบูรณ์

examples/01_board_knows_itself.py ย่อมาจากตัวอย่าง examples/s01/10_board_knows_itself.py ของหลักสูตร AIoT in Action อ่านไล่ตามนี้

• ท่าที่ 1 ถามบอร์ด info = gpio.board_info() ถามครั้งเดียว เก็บไว้ในตัวแปร
• ท่าที่ 2 ล้างจอ ui.screen() ลบของเก่าบนจอ แล้วรอ 200 มิลลิวินาทีให้จอพร้อม
• ท่าที่ 3 วางป้าย ui.Label(ข้อความ, x=..., y=..., color=..., value=ขนาดตัวอักษร) แล้วเคาะ ui.poll() ให้ป้ายขึ้นทันที
• ท่าที่ 4 เขียนลงลิ้นชัก lcd.print(...) สำหรับรายละเอียดที่ยาวเกินจอ

ภาพจอจาก BENTO Emulator ของตัวอย่างในบทนี้ (คลิกชื่อไฟล์เพื่อเปิดโค้ด)

01_board_knows_itself.py

ฝึกเติม

ท้ายไฟล์ตัวอย่างมีโจทย์ “ตาคุณ” อยู่ ให้เพิ่มลูปพิมพ์รายชื่อปุ่มจาก info["btn_names"] แบบเดียวกับลูปพิมพ์รายชื่อไฟ ก่อนรัน ลองทำนายว่าอีมูเลเตอร์จะรายงานปุ่มกี่ปุ่ม แล้วรันเทียบ

เช็กความเข้าใจ

ตอบคำถามใน quiz.yaml ถูกตั้งแต่ 80% ขึ้นไปถือว่าผ่าน

ไปต่อ

• ลองกด HW แล้วดูว่าแผงฮาร์ดแวร์จำลองมีอะไรบ้าง บทต่อไปเราจะสั่งหลอดไฟบนแผงนั้น
• ถ้าอยากรู้ว่าบอร์ดจริงตอบต่างจากอีมูเลเตอร์อย่างไร เปิดไฟล์ต้นฉบับ examples/s01/10_board_knows_itself.py ที่ถามบอร์ดต่อว่าโมดูล machine มีคำสั่งไหนบ้าง

สะท้อนคิด

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

คำถามทบทวน

ลองตอบเองก่อน แล้วค่อยเปิดดูเฉลย

1. เรียงขั้นตอนรันโปรแกรมใน BENTO Emulator ให้ถูกลำดับ (เป้าหมายข้อ 1)

   1. กด ▶ Run ในแผงอีมูเลเตอร์
   2. เปิด https://ide.tesaiot.dev/ แล้วสลับเป็นมุมมอง Python
   3. วางโค้ดลงในช่องแก้โค้ด
   4. กดปุ่ม BENTO Emulator บนแถบเครื่องมือ
   ดูเฉลย

   ลำดับที่ถูก: B. เปิด https://ide.tesaiot.dev/ แล้วสลับเป็นมุมมอง Python → C. วางโค้ดลงในช่องแก้โค้ด → D. กดปุ่ม BENTO Emulator บนแถบเครื่องมือ → A. กด ▶ Run ในแผงอีมูเลเตอร์

   เปิด IDE วางโค้ด เปิดแผงอีมูเลเตอร์ แล้วจึงกดรัน ถ้ามีบอร์ดจริงใช้ Connect กับ Program to Device แทนสองขั้นสุดท้าย

2. หลังสร้าง ui.Label แล้ว ควรเรียกคำสั่งใดเพื่อให้ป้ายขึ้นจอทันที (เป้าหมายข้อ 1)

   1. print()
   2. ui.poll()
   3. lcd.clear()
   4. gpio.board_info()
   ดูเฉลย

   คำตอบ: B. ui.poll()

   ui.poll() ให้จอประมวลผลงานที่ค้างอยู่ ถ้าไม่เรียก ป้ายก็ขึ้นในที่สุดแต่ช้ากว่า จนดูเหมือนโค้ดพัง

3. ข้อใดคือความต่างระหว่าง Eva Kit กับ TESAIoT Dev Kit (เลือกได้มากกว่าหนึ่งข้อ) (เป้าหมายข้อ 2)

   1. จำนวนหลอด LED ที่ Python สั่งได้ (3 ดวง กับ 5 ดวง)
   2. Dev Kit มีเซนเซอร์อุณหภูมิและความชื้น ความกดอากาศ และเรดาร์เพิ่ม
   3. Eva Kit ใช้ภาษา C ได้อย่างเดียว เขียน MicroPython ไม่ได้
   4. ขนาดจอต่างกันมาก โค้ดชุดเดียวใช้ร่วมกันไม่ได้
   ดูเฉลย

   คำตอบ: A. จำนวนหลอด LED ที่ Python สั่งได้ (3 ดวง กับ 5 ดวง) · B. Dev Kit มีเซนเซอร์อุณหภูมิและความชื้น ความกดอากาศ และเรดาร์เพิ่ม

   ทั้งสองบอร์ดรัน MicroPython ของ BENTO และมีจอ 800 x 480 เท่ากัน ตัวอย่างชุดเดียวกันจึงรันได้ทั้งสองบอร์ด

4. คำถามใดที่ BENTO Emulator ตอบได้น่าเชื่อถือที่สุด (เป้าหมายข้อ 3)

   1. สัญญาณ WiFi ในห้องเรียนแรงพอไหม
   2. โปรแกรมรันจบโดยไม่มีข้อผิดพลาด และหน้าจอออกมาตามที่ตั้งใจไหม
   3. ค่าเซนเซอร์บนบอร์ดของฉันแม่นยำแค่ไหน
   4. บอร์ดกินไฟเท่าไรระหว่างรัน
   ดูเฉลย

   คำตอบ: B. โปรแกรมรันจบโดยไม่มีข้อผิดพลาด และหน้าจอออกมาตามที่ตั้งใจไหม

   อีมูเลเตอร์เหมาะกับการเรียนแนวคิดและตรวจโปรแกรม ส่วนเรื่องสัญญาณ ความแม่นของเซนเซอร์ และพลังงาน ต้องวัดบนบอร์ดจริง

อ้างอิงบทเรียนนี้

ถ้านำบทเรียนนี้ไปสอน ทำสไลด์ หรือทำเอกสารต่อ ให้อ้างอิงด้วยข้อความนี้ ถ้าดัดแปลงเนื้อหา ให้เติม (ดัดแปลง)ต่อท้ายชื่อบทเรียน

"รู้จักบอร์ดและอีมูเลเตอร์" จาก TESA Open Knowledge โดยสมาคมสมองกลฝังตัวไทย (Thai Embedded Systems Association: TESA) https://github.com/tesaiot/tesa-qualification-program สัญญาอนุญาต CC BY-NC 4.0

ข้อความอ้างอิงภาษาอังกฤษ: "Meet the board and the emulator" from TESA Open Knowledge by the Thai Embedded Systems Association (TESA), https://github.com/tesaiot/tesa-qualification-program, licensed under CC BY-NC 4.0

ลิงก์บทเรียน: https://tesaiot.github.io/tesa-qualification-program/courses/explorer/m01-meet-embedded/l02-board-and-emulator/

บทเรียนนี้ดัดแปลงจากต้นฉบับด้านล่าง เมื่ออ้างอิงให้คงเครดิตต้นฉบับไว้ด้วย
https://github.com/Advance-Innovation-Centre-AIC/embedded-systems-for-aiot-developer/blob/a80bbe88a34bcb9bb8d991f42f9252b77cdab079/examples/s01/10_board_knows_itself.py · ตัวอย่างโค้ดทุกไฟล์ในหลักสูตรนี้ย่อและดัดแปลงจากตัวอย่างของ AIoT in Action (MIT) ใช้ API ของ BENTO MicroPython ตามที่ตัวอย่างต้นฉบับใช้ ไม่มีการเพิ่มคำสั่งใหม่

วิธีอ้างอิง TESA ฉบับเต็ม