โครงของไฟล์ s06_physics_viz.py

ทั้งไฟล์อ่านเป็นประโยคเดียว: "เลือกปริมาณ → อ่านค่าดิบ → คำนวณเป็นปริมาณจริง → ส่งขึ้น Seg7/Bar/Chart → วนซ้ำ"

ตัวเลขบรรทัด (:94, :103, :112, :125) ชี้จุดที่คุณต้องเติมสูตรในไฟล์ฝึก จำโครงนี้ไว้ เดี๋ยวไล่ดูทีละส่วน

ไล่โค้ด (1) — เตรียมของก่อนลูป

ส่วนบนของไฟล์ สร้าง widget ครั้งเดียว จับความดันอ้างอิง และเช็กไมค์:

dd = ui.Dropdown(text="\n".join(v[0] for v in VIEWS), x=20, y=42, w=280)
seg = ui.Seg7("--", x=44, y=120, color=GREEN)
bar = ui.Bar(x=44, y=250, w=312, h=16, min=0, max=100, value=0, color=AMBER)
chart = ui.Chart(x=420, y=90, w=352, h=210, min=0, max=100)

try:                                    # ไมค์ PDM มีเฉพาะบนบอร์ด
    from machine import PDM_PCM
    pdm = PDM_PCM(0, sck="P8_5", data="P8_6", sample_rate=16000)
    has_mic = True
except Exception:
    has_mic = False

p0, _ = sensors.dps368.pressure_temperature()   # จุด 0 เมตรของ altitude

• ทั้งหมดนี้ให้ไว้แล้ว — เป็น "70% ที่เตรียมให้" งานของคุณคือสูตรตรงกลางในลูป
• p0 จับครั้งเดียวก่อนลูป (นอกลูป) เพราะเป็นจุดอ้างอิงที่ไม่เปลี่ยน

โครงนี้คือ "สร้างครั้งเดียว" ของบทเรียน 1.4–1.5 เป๊ะ — widget อยู่นอกลูป ในลูปแค่เปลี่ยนค่า ไม่สร้างใหม่ทุกรอบ

ไล่โค้ด (2) — สูตรที่ 1: Tilt

ช่องเติมที่ 1 (บรรทัด :94): แปลง raw ของ IMU เป็นมุมเอียง

if sel == 0:                                   # Tilt
    ax, ay, az, gx, gy, gz = sensors.bmi270.motion()
    # เติม: มุมเอียงจาก accelerometer -> roll, pitch = dsp.tilt(ax, ay, az)
    roll, pitch = 0.0, 0.0
    pass
    dom = pitch if abs(pitch) >= abs(roll) else roll

• แทน pass (และลบ roll, pitch = 0.0, 0.0) ด้วย roll, pitch = dsp.tilt(ax, ay, az)
• ถ้าลืมเติม: เกจจะค้างที่ 0 ตลอด เพราะ roll, pitch ถูกตั้งเป็น 0 ไว้เป็น placeholder
• ระวังลำดับ: dsp.tilt คืน (roll, pitch) ไม่ใช่ (pitch, roll)

เราวาง roll, pitch = 0.0, 0.0 ไว้ก่อน เพื่อให้ไฟล์ รันได้ ตั้งแต่ยังไม่เติม (โชว์ 0) พอเติมจริงค่าถึงจะขยับ — เทคนิคเดียวกับ r = None ในบทเรียน 1.1–1.3

ไล่โค้ด (3) — สูตรที่ 2: Energy

ช่องเติมที่ 2 (บรรทัด :103): เขียนสูตรขนาดเวกเตอร์เอง

elif sel == 1:                                 # Energy
    ax, ay, az, gx, gy, gz = sensors.bmi270.motion()
    # เติม: energy = ขนาดเวกเตอร์ความเร่ง ลบ 1g
    #       mag = math.sqrt(ax*ax + ay*ay + az*az) / 9.81 ; energy = abs(mag - 1.0)
    energy = 0.0
    pass
    head = "%.2f" % energy

• เติมสองบรรทัด: mag = math.sqrt(ax*ax + ay*ay + az*az) / 9.81 (m/s² เป็น g) แล้ว energy = abs(mag - 1.0)
• นี่คือ "คณิตที่คุณเขียนเอง" ไม่มีฟังก์ชันสำเร็จ — พีทาโกรัสสามมิติ + ลบฐาน 1g
• ถ้าลืมลบ 1.0: ตอนวางนิ่ง energy จะค้างที่ ~1.0 แทนที่จะเป็น 0

ลองทดลอง: วางนิ่งควรได้ใกล้ 0 เขย่าเบาๆ ได้ ~0.2 เขย่าแรงได้เกิน 1 — ถ้าค่าไม่เป็นแบบนี้ กลับมาเช็กว่าลบ 1g หรือยัง

ไล่โค้ด (4) — สูตรที่ 3: Altitude

ช่องเติมที่ 3 (บรรทัด :112): เรียกฟิสิกส์ความดันสำเร็จรูป

elif sel == 2:                                 # Altitude
    p, t = sensors.dps368.pressure_temperature()
    # เติม: ความสูงจากความดัน เทียบกับ p0 -> alt = dsp.altitude(p, p0)
    alt = 0.0
    pass
    head = "%.1f" % alt

• แทน pass ด้วย alt = dsp.altitude(p, p0) — p0 จับไว้ก่อนลูปแล้ว
• ยกบอร์ดขึ้น ~1 เมตร ค่าควรขึ้น ~+1.0 วางลงกลับมา ~0
• ความดันไวต่อลม/แอร์ ค่าอาจแกว่งเล็กน้อย — ปกติ เดี๋ยวบทเรียน 4.1–4.2 เราจะกรองให้นิ่ง

dsp.altitude ทำสูตร barometric ให้ทั้งดุ้น เราแค่ป้อนความดันปัจจุบันกับจุดอ้างอิง — นี่คือพลังของ dsp: ฟิสิกส์ยากๆ ถูกห่อเป็นฟังก์ชันเดียว

ไล่โค้ด (5) — สูตรที่ 4: dBFS

ช่องเติมที่ 4 (บรรทัด :125): แปลง RMS เป็น decibel (บนบอร์ด)

else:                                          # Sound dBFS
    if has_mic:
        pdm.readinto(mbuf)
        acc = 0
        for s in mbuf:
            acc += s * s
        rms = math.sqrt(acc / len(mbuf))
        # เติม: db = 20 * math.log10(rms / 32768.0)
        db = -96.0
        if rms > 0:
            pass
        head = "%d" % int(db)

• ในบล็อก if rms > 0: แทน pass ด้วย db = 20 * math.log10(rms / 32768.0)
• เช็ก rms > 0 ก่อน เพราะ log10(0) คำนวณไม่ได้ (เงียบสนิท = ค่าพื้น -96)
• ช่องนี้ทดสอบด้วยเสียงจริง บนบอร์ด (บน Emulator ค่าที่เห็นมาจากเสียงสังเคราะห์)

สี่ช่องนี้คือสี่สูตรฟิสิกส์ของชุดบทเรียน — เติมครบเมื่อไร ทั้งสี่ปริมาณจะมีชีวิตขึ้นมาพร้อมกัน

ลงมือทำ — เติมสูตรทั้ง 4 จุด

เปิด s06_physics_viz.py มี # เติม: วางไว้ 4 จุด ตรงสูตรแปลงของแต่ละปริมาณ:

ขั้นตอน:

1. ไล่หา # เติม: ทีละจุด แทน placeholder ด้วยสูตรตามคำใบ้
2. กด Run (Emulator) หรือ Program to Device (บอร์ด)
3. เลือกปริมาณใน dropdown แล้วขยับ/ยก/ส่งเสียง ดูค่าเปลี่ยน ถ้ายังค้าง กลับมาเช็ก indent กับชื่อฟังก์ชัน

เติมทีละสูตร ทดสอบทีละปริมาณ — เติม tilt เสร็จลองเอียงก่อน ใช้ได้แล้วค่อยไปสูตรถัดไป จะจับบั๊กง่ายกว่าเติมรวดเดียวสี่อัน

ลงมือ (1) — รันบน BENTO Emulator

ไม่มีบอร์ดก็เริ่มได้ (สามปริมาณแรกเล่นได้เต็มที่บน Emulator):

1. เปิด ide.tesaiot.dev (BENTO Emulator) ในเบราว์เซอร์
2. เปิดไฟล์ s06_physics_viz.py (หรือวางโค้ด)
3. เติมสูตรทั้ง 4 จุด แล้วกด Run
4. เลือก Tilt ลากแผ่นเอียง → ดูมุมเปลี่ยน · เลือก Energy กดปุ่ม Shake → ดูพลังงานพุ่ง · เลือก Altitude → ดูความสูงจำลอง
5. เลือก Sound จะเห็นระดับเสียงจากเสียงสังเคราะห์ของ Emulator — ไว้ทดสอบกับเสียงจริงบนบอร์ด

Emulator ใช้เซนเซอร์ จำลอง แต่ API เหมือนบอร์ดจริงทุกบรรทัด — เหมาะกับซ้อมสูตร Tilt/Energy/Altitude ที่บ้าน แล้วมายืนยัน + เล่น dBFS กับของจริงบนบอร์ด

หน้าตาจริงบน BENTO Emulator

ภาพนี้คือ s06_physics_viz ที่เติมสูตรครบแล้วรันบน Emulator ค่าที่เห็นคือผลของสูตร dsp.tilt ที่คุณเพิ่งเติม ไม่ใช่ภาพนิ่ง ลองเปิด ide.tesaiot.dev แล้วขยับดูเองได้เลย

ลงมือ (2) — รันบนบอร์ด BENTO จริง

บนบอร์ดจริงใช้ของจริง เซนเซอร์จริง ครบทั้งสี่ปริมาณรวมทั้งไมค์:

1. เสียบบอร์ดเข้าคอมด้วยสาย USB
2. เปิด s06_physics_viz.py ใน BENTO IDE กด Program to Device
3. Tilt — เอียงบอร์ดช้าๆ ทั้งสองแกน ดูมุมเด่นบน Seg7
4. Energy — วางนิ่ง (~0) แล้วเขย่า (พุ่งขึ้น) เทียบกัน
5. Altitude — ยกบอร์ดขึ้น-ลง 1 เมตร ดูความสูงเปลี่ยน
6. Sound — ปรบมือ/พูดใส่ไมค์ ดู dBFS วิ่งขึ้นตอนมีเสียง

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

แหล่งเรียนรู้เพิ่มเติม

อยากเจาะลึกคณิต-ฟิสิกส์ของชุดบทเรียนนี้ เลือกดูตามหัวข้อที่อยากต่อยอด:

วิดีโอ

• ตรีโกณ & atan2 ของมุม — ช่อง 3Blue1Brown: https://www.youtube.com/@3blue1brown
• decibels และสเกล log อธิบายเห็นภาพ — ช่อง Computerphile: https://www.youtube.com/@Computerphile
• signal processing เบื้องต้นด้วย Python — ช่อง Sentdex: https://www.youtube.com/@sentdex

ภาพ / เอกสารอ้างอิง

• แกน roll / pitch / yaw ของวัตถุบิน (ที่มา: commons.wikimedia.org, CC BY-SA): https://commons.wikimedia.org/wiki/File:Flight_dynamics_with_text.png
• นิยาม atan2 และควอดรันต์ (ที่มา: en.wikipedia.org/wiki/Atan2, CC BY-SA): https://en.wikipedia.org/wiki/Atan2
• นิยาม dBFS เทียบ Full Scale (ที่มา: en.wikipedia.org/wiki/DBFS, CC BY-SA): https://en.wikipedia.org/wiki/DBFS

วิดีโอ/ภาพภายนอกเป็นของเจ้าของต้นฉบับ ใช้เพื่อการศึกษา อ้างอิงลิงก์ต้นทาง

ชัยชนะที่เห็นได้ + MVP ของชุดบทเรียนนี้

MVP ของบทเรียน 3.1–3.2 (เกณฑ์ผ่านของชุดบทเรียน): สัญญาณดิบ → ปริมาณที่คำนวณได้ → แสดงเห็นบนจอ ครบวงอย่างน้อย หนึ่งปริมาณ (เอียงบอร์ดแล้วมุมเปลี่ยน หรือยกบอร์ดแล้วความสูงเปลี่ยน)

• ทำบน Emulator (Tilt/Energy/Altitude) หรือ บอร์ดจริง (ครบสี่ รวม dBFS)
• อธิบายได้ว่าสูตรที่เติมแปลง "ตัวเลขดิบ" เป็น "ปริมาณอะไร" และหน่วยคืออะไร

"แสดงเห็นบนจอ" ไม่ใช่แค่ "ตัวเลขขยับ" — คุณต้องบอกได้ว่า energy 0.8 หมายความว่าอะไร ทำไม tilt ใช้ atan2 ได้โดยไม่ต้องรู้หน่วย accel

บันไดช่วยเหลือ — ใบ้ → เริ่มจากโครง → เฉลย → ฉบับเต็ม

ถ้าติด ให้ไต่บันไดนี้ทีละขั้น อย่าเพิ่งกระโดดไปดูเฉลย เพราะสูตรจะเข้าหัวตอนที่คุณพยายามเองก่อน:

• ใบ้ — คำใบ้อยู่ในคอมเมนต์ # เติม: ทั้ง 4 จุดในไฟล์ฝึก + ตารางสองหน้าที่แล้ว บอกว่าแต่ละช่องเติมสูตรอะไร
• เริ่มจากโครง — s06_physics_viz.py มีโครงครบทั้งไฟล์แล้ว (รันได้ โชว์ 0/board) เหลือแค่ 4 สูตรให้เติม
• เฉลย — s06_physics_viz.py เติมครบพร้อมคอมเมนต์อธิบายทุกสูตร (อ่านให้เข้าใจ ปิดไฟล์ แล้วพิมพ์เอง)
• ฉบับเต็ม — s06_physics_viz_full.py ฉบับขัดเรียบร้อย เพิ่ม hi/lo hold, ป้าย STEADY/ACTIVE และปุ่ม Reset

ลองเขียนเองให้สุดก่อนนะ ถ้าติดจริงๆ ค่อยเปิดเฉลยดูทีละสูตร แล้วกลับมาพิมพ์เอง — เดี๋ยวเราค่อย ๆ แกะฟิสิกส์ไปด้วยกัน

เชื่อมโยงรากฐาน — วันนี้เราแตะอะไรไปบ้าง

การแปลงสัญญาณดิบซ่อนแนวคิด Processing หลายชั้นที่จะใช้ไปตลอดคอร์ส:

ฝั่ง Processing / คณิต-ฟิสิกส์

• raw → derived → viz — โครงหัวใจของทั้ง Pillar 2 ใช้ซ้ำกับทุกปริมาณ
• สูตรสำเร็จ vs สูตรที่เขียนเอง — dsp.tilt/dsp.altitude (สำเร็จ) เทียบ energy/dBFS (เขียนเอง)
• normalize — บีบปริมาณต่างหน่วยเข้าช่วง 0..100 เดียว เพื่อ viz (clamp100)
• log สเกล — decibel บีบช่วงกว้างให้อ่านออก (จะเจ่ออีกใน FFT บทเรียน 4.3–4.4)

ฝั่ง MicroPython / โครงโปรแกรม

• โครงร่วมของบทเรียน 1.4–1.5 — import → สร้างครั้งเดียว → ลูป → ui.poll เดินตามเป๊ะ
• จับ p0 ก่อนลูป — ค่าอ้างอิงที่ไม่เปลี่ยน คำนวณครั้งเดียว
• เก็บกวาดตอนจบ — finally: pdm.deinit() คืนฮาร์ดแวร์ไมค์เสมอ

สูตรวันนี้คือ "ก้อนแรก" ของ Analysis: พอเราแปลงดิบเป็นปริมาณได้ ชุดบทเรียนถัด ๆ ไป จะเอาปริมาณพวกนี้ไปกรอง (บทเรียน 4.1–4.2) แปลงเป็นสเปกตรัม (บทเรียน 4.3–4.4) จนเป็น feature ที่โมเดลกินได้จริง (บทเรียน 4.5–4.6)

ใช้จริงที่ไหน — Processing ในโลกจริง

สี่สูตรที่เราเขียนวันนี้ ไม่ใช่แบบฝึกหัดลอยๆ ทุกสูตรเป็นหัวใจของอุปกรณ์จริงที่ขายอยู่:

เห็นไหมว่าสี่สูตรพื้นฐานนี้อยู่ในของใช้รอบตัวเต็มไปหมด — Processing ที่ดูเรียบง่ายวันนี้ คือชั้นที่ทำให้ "ตัวเลขดิบ" กลายเป็นฟีเจอร์ที่ผลิตภัณฑ์จริงพึ่งพา

งานทำเอง + สรุปบทเรียน

งานทำเอง (ท้ายบทเรียน):

1. เติม s06_physics_viz.py ให้ครบทั้ง 4 สูตร รันได้จริง (Emulator หรือบอร์ด)
2. ทดสอบอย่างน้อย 3 ปริมาณ (Tilt → Energy → Altitude) จดว่าแต่ละอันต้องทำอะไรถึงจะเห็นค่าเปลี่ยนชัด
3. หา "ค่าอ้างอิงตอนนิ่ง" ของ Energy (วางบอร์ดนิ่งควรใกล้ 0) แล้วอธิบายว่าทำไมต้อง ลบ 1g ในสูตร

ใบ้ข้อ 3 — ลองลบ - 1.0 ออกชั่วคราวแล้วดูว่าค่าตอนนิ่งเปลี่ยนไปเป็นเท่าไร นั่นคือ "ฐานแรงโน้มถ่วง" ที่เราตัดทิ้ง

วันนี้เราได้: เข้าใจว่าทำไมต้อง Processing · จับโครง raw → derived → viz · เขียน/เรียก 4 สูตรฟิสิกส์ (tilt/energy/altitude/dBFS) · เลือก widget ให้เข้ากับข้อมูล · แสดงเกจสดๆ

ชุดบทเรียนถัดไป (บทเรียน 3.3–3.4) เราจะต่อยอด Processing ไปอีกขั้น — เอาปริมาณที่แปลงได้มา ตัดสินด้วยกฎ (threshold) เช่น "สบาย/ร้อน" จากอุณหภูมิ+ความชื้น นี่คือ classification แบบคลาสสิกก่อนถึง ML เจอกันครับ