นวัตกรรมแขนกลอัจฉริยะ
(Smart 3DOF Robotic Arm: From CAD to AI)

ช่วงบ่าย · ส่วนที่ 2 · ⏱ 1.5 ชม.🖨 การผลิต (Slicing & 3D Printing)

รูป: เครื่องพิมพ์ 3 มิติกำลังพิมพ์ Gripper — ตั้งค่า Infill และ Support ให้ถูกจุดก่อนสั่งพิมพ์

📥 วิธีเริ่มต้นใช้งาน (สมัคร + “ติดตั้ง”)

1. เปิดเว็บ onshape.com แล้วกด Sign Up / Get Started Free — สมัครฟรี ไม่ต้องใช้บัตรเครดิต ได้สิทธิ์ใช้งานทันที
2. สำหรับนักเรียน: กด Create A Student Account (ผ่านหน้า Education) เพื่อรับสิทธิ์เต็มรูปแบบ — แนะนำให้ผู้สอนสมัครผ่านโปรแกรมการศึกษาเพื่อให้ทั้งห้องได้ใช้ฟีเจอร์ครบ
3. เข้าใช้งานที่ cad.onshape.com ผ่านเบราว์เซอร์ Chrome / Edge / Firefox (อินเทอร์เน็ตควรเสถียร ประมาณ 10 Mbps ขึ้นไป)
4. สำหรับมือถือ/แท็บเล็ต: ดาวน์โหลดแอป Onshape จาก App Store (iOS) หรือ Google Play (Android) — ใช้ดูและแก้ไขแบบเบื้องต้นได้

🧭 ทำความรู้จัก UI เบื้องต้น

รูป: หน้าจอจำลอง Onshape — Feature Toolbar ด้านบน, Feature Tree ด้านซ้าย, View Cube มุมขวา

🛠 5 ขั้นตอนการใช้งานพื้นฐาน (ใช้ทำ Mini-Project Gripper ได้เลย)

⌨️ ทางลัดที่ใช้บ่อย

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

• Onshape Learning Center — คอร์สฟรีแบบเป็นขั้นตอน: learn.onshape.com
• Onshape Help Center — คู่มือครบทุกคำสั่ง: cad.onshape.com/help
• Onshape AI Advisor — ผู้ช่วย AI ในตัว ตอบคำถามได้ทันที (ดูรายละเอียดด้านล่าง)
• Onshape Forums — กระทู้ถาม–ตอบของชุมชนผู้ใช้ทั่วโลก

🤖 AI ใน Onshape — มี AI Agent ด้วย!

Onshape มี AI ให้ใช้จริง 3 ระดับ — เหมาะกับการสอดแทรกหัวข้อ AI ในค่ายนี้ด้วย:

• Onshape AI Advisor (beta) — ผู้ช่วย AI ในตัวของ Onshape ตอบคำถามเกี่ยวกับการใช้ CAD ได้ทันที โดยอ้างอิงจากเอกสารทางการของ Onshape (ถามได้ทั้งเรื่อง Sketch, Extrude, การประกอบ ฯลฯ) เข้าถึงได้จากเมนู Help / ไอคอนเครื่องหมายคำถามในโปรแกรม
• Onshape Labs — AI in CAD — โปรแกรม Early-Access (ทดลองฟีเจอร์ล่วงหน้า) ให้ผู้ใช้ทดสอบฟีเจอร์ AI สำหรับการออกแบบ เช่น AI ช่วยสร้าง/แนะนำฟีเจอร์การขึ้นแบบ
• FeatureScript MCP Server — ตัวเชื่อมที่เปิดทางให้ AI Agent ภายนอก (เช่น GitHub Copilot, Claude) เข้ามาสร้างหรือแก้ไขโมเดล CAD ได้ด้วยภาษาธรรมชาติหรือโค้ด — เหมือนให้ AI เป็น “ผู้ช่วยออกแบบ” ข้าง ๆ นักเรียน

ช่วงบ่าย · ⏱ 3 ชม.🧮 ศาสตร์แห่งการเคลื่อนไหว (3DOF Kinematics)

รูป: แขนกล 3 ข้อต่อบนแกน X-Y-Z — เปลี่ยนมุม θ แล้วพิกัดปลายแขนเปลี่ยนตาม

📊 เกณฑ์ให้คะแนน Mini-Hackathon

🧮 ขั้นตอนการคำนวณ 3D FK (ทีละขั้น)

รูป: SIDE VIEW แบบเต็มป้าย — d1…d6, θ4, θ5, 90°, z (ใช้ในขั้นตอนด้านล่าง)

ขั้นที่ 1 — หา d3 (องค์ประกอบแนวตั้งของ L1)

sin θ2 = d3 / l1
   d3 = sin 30° × 10 = 5.0 cm

ขั้นที่ 2 — หามุม θ4 และ θ5

θ4 = 180° − (θ2 + 90°) = 180° − (30° + 90°) = 60°
θ5 = θ3 − θ4 = 140° − 60° = 80°

ขั้นที่ 3 — หา d6 แล้วคำนวณความสูง z

cos θ5 = d6 / l2   →   d6 = cos 80° × 10 = 1.74 cm
   z = d2 + d3 − d6 = 7 + 5.0 − 1.74 = 10.26 cm

ขั้นที่ 4 — หา d4, d5 และระยะเอื้อมแนวนอน d1

d4 = cos θ2 × l1 = cos 30° × 10 = 8.66 cm
   d5 = sin θ5 × l2 = sin 80° × 10 = 9.85 cm
   d1 = d4 + d5 = 8.66 + 9.85 = 18.51 cm

ขั้นที่ 5 — หา x และ y จาก TOP VIEW

x = cos θ1 × d1 = cos 60° × 18.51 = 9.26 cm
   y = sin θ1 × d1 = sin 60° × 18.51 = 16.03 cm

🤖 แขนกลตัวอย่าง (3 DOF) และวิธีคิด IK

รูป: โครงสร้างแขน — Base, Shoulder, Elbow, Wrist, End-Effector พร้อมแกน x/y/z

แขนตัวอย่างมีอิสระ 3 แกน (3 DOF): Swing (หมุนทั้งแขนรอบฐาน), Main (เลื่อนข้อศอกเข้า–ออก), Actuator (เลื่อนปลายแขนขึ้น–ลง) — ข้อดีของแขน 3 DOF คือ ทุกตำแหน่งของปลายแขนมีท่าคำตอบเดียว (unique solution) ทำให้แก้ IK แบบวิเคราะห์ (เรขาคณิต) ได้โดยไม่ต้องใช้การคำนวณเชิงตัวเลขที่ซับซ้อน

🧭 ขั้นตอนที่ 1 — Swing IK (มุมมองจากด้านบน)

รูป: “Easy” = จุดหมุนอยู่กึ่งกลาง (ใช้ตรีโกณมิติตรง ๆ) · “Less easy” = จุดหมุนเยื้องศูนย์ (ต้องใช้การค้นหา)

กรณีกึ่งกลาง: หามุมหมุนง่าย ๆ ด้วย atan2 แต่แขนจริงมีระนาบการทำงานเยื้องจากแกนหมุน (ดูภาพขวา) ทำให้ถ้าใช้ตรีโกณมิติตรง ๆ แขนจะชี้เฉไปด้านข้าง

วิธีที่ผู้เขียนใช้: Binary Search (วิธีแบ่งครึ่ง / Bisection Method) — กำหนดขอบบน–ล่างของมุม ตรวจจุดกึ่งกลางว่ามาก/น้อยกว่าเป้าหมาย แล้วลดช่วงลงครึ่งหนึ่งทุกครั้ง 3–5 รอบได้ความแม่นยำต่ำกว่า 0.3° (เพียงพอสำหรับเซอร์โว)

import numpy as np

def normalize(v):
    return v / np.linalg.norm(v)

def signed_angle(A, B):
    """มุมมีเครื่องหมาย: บวก = A หมุนตามเข็มนาฬิกาจาก B (ใช้ dot product)"""
    A, B = normalize(A), normalize(B)
    perp = np.array([-B[1], B[0]])          # เวกเตอร์ตั้งฉากกับ B ไปทางตามเข็มนาฬิกา
    return np.rad2deg(np.arctan2(np.dot(A, perp), np.dot(A, B)))

# เริ่มต้นจากมุมคร่าว ๆ (naive) แล้วค้นหาแบบแบ่งครึ่ง
start_theta = np.rad2deg(np.arctan2(goal[1], goal[0]))   # atan2 แก้ quadrant ให้ถูกต้อง
lo, hi = start_theta - 60, start_theta + 60               # ขอบเขตเริ่มต้น
for _ in range(8):                                        # 8 รอบ = แม่นยำมาก
    mid = (lo + hi) / 2
    err = signed_angle(arm_direction(mid), goal - shoulder(mid))
    if err > 0: lo = mid      # มากเกินไป -> ใช้ mid เป็นขอบบน
    else:       hi = mid      # น้อยเกินไป -> ใช้ mid เป็นขอบล่าง
swing = (lo + hi) / 2

ผลลัพธ์ที่ได้จากขั้นนี้ด้วย: ระยะรัศมีจากข้อต่อ Shoulder ถึงปลายแขน (goal_radial) — ใช้ต่อในขั้นตอนที่ 2

goal_radial = np.linalg.norm(goal - shoulder(swing))   # ระยะ 2D บนระนาบการทำงาน

🔺 ขั้นตอนที่ 2 — Plane IK (มุมมองด้านข้าง) หาตำแหน่งข้อศอก

รูป: วงกลม 2 วง (ศูนย์กลางที่ Shoulder รัศมี 148mm = Main arm · ศูนย์กลางที่ Wrist รัศมี = Forearm) — ข้อศอกอยู่ที่จุดตัดบน

เปลี่ยนมาใช้พิกัด 2D ในระนาบการทำงาน (แกน x = ระยะ radial, แกน y = ความสูง) — main arm กับ forearm สร้างสามเหลี่ยมโดยมีข้อศอกอยู่ที่ยอด เนื่องจากข้อศอกอยู่ห่างจาก Shoulder = ความยาว main arm และห่างจาก Wrist = ความยาว forearm เราจึงวาดวงกลม 2 วง แล้วหาจุดตัด — ข้อศอกคือจุดตัดบน (ค่า y มากสุด)

def circle_intersection(c1, r1, c2, r2):
    """จุดตัดของวงกลม 2 วง — คืนจุดบนสุด (y มากสุด) หรือ None ถ้าหาคำตอบไม่ได้"""
    d = np.linalg.norm(c2 - c1)
    if d > r1 + r2:        return None   # วงแยกกัน -> ระยะเอื้อมไม่ถึง
    if d < abs(r1 - r2):   return None   # วงหนึ่งกลืนอีกวง -> โครงสร้างเป็นไปไม่ได้
    a = (r1*r1 - r2*r2 + d*d) / (2*d)
    h = np.sqrt(r1*r1 - a*a)
    p = c1 + a * (c2 - c1) / d
    u = np.array([-(c2[1]-c1[1]), c2[0]-c1[0]]) / d   # ทิศตั้งฉาก
    p1, p2 = p + h*u, p - h*u
    return max(p1, p2, key=lambda v: v[1])            # เลือกข้อศอกตำแหน่งบน

elbow = circle_intersection(shoulder, MAIN_LEN, wrist_goal, FOREARM_LEN)

✅ สรุปแนวคิดของบทความนี้

• ได้ มุม Swing (ขั้นตอนที่ 1) + ตำแหน่งข้อศอก (ขั้นตอนที่ 2) = ท่าแขนที่สมบูรณ์
• ถ้าต้องการสามารถแปลงกลับเป็นพิกัด 3D ได้โดยใช้มุม swing + ระนาบการทำงาน
• แขนจริงอาจมีจุดหมุนเยื้องศูนย์ — การค้นหาแบบ Binary Search ช่วยแก้ได้โดยไม่ต้องนั่งคิดเรขาคณิตยาก ๆ

🧩 DH Parameters คืออะไร

Denavit–Hartenberg (DH) เป็นวิธีมาตรฐาน (ตีพิมพ์ปี 1955) ในการอธิบายโครงสร้างแขนหุ่นยนต์ ด้วยพารามิเตอร์เพียง 4 ค่าต่อข้อต่อ — ต่างจากตรีโกณมิติที่ต้องคิดเฉพาะโครงสร้าง DH ใช้ได้กับแขนทุกแบบและหลายข้อต่อ (รวมถึงหุ่นยนต์อุตสาหกรรม 6 แกน)

พารามิเตอร์ 4 ตัว สำหรับข้อต่อที่ i:

📋 ตาราง DH ของแขน 3 DOF (ตัวอย่าง)

ค่า a, d, α เป็นค่าคงที่ของโครงสร้าง ส่วน θ เป็นตัวแปรที่เปลี่ยนตามข้อต่อหมุน (Revolute)

🧮 เมทริกซ์แปลง (Transformation Matrix) ของ DH

Tᵢ = Rot(z, θᵢ) · Trans(z, dᵢ) · Trans(x, aᵢ) · Rot(x, αᵢ)

    ┌  cosθ   −sinθ·cosα    sinθ·sinα    a·cosθ  ┐
T = │  sinθ    cosθ·cosα   −cosθ·sinα    a·sinθ  │
    │    0        sinα        cosα        d      │
    └    0         0           0          1      ┘

FK ทั้งแขน = T₁ × T₂ × T₃ (คูณเมทริกซ์ต่อกันทุกข้อต่อ) — ตำแหน่งปลายแขน (x, y, z) อยู่ในคอลัมน์สุดท้ายของผลลัพธ์

🐍 โค้ด Python: คำนวณ FK ด้วย DH Parameters

import numpy as np

def dh_transform(a, alpha, d, theta):
    """เมทริกซ์แปลง DH สำหรับหนึ่งข้อต่อ (มุมเป็นเรเดียน)"""
    ct, st = np.cos(theta), np.sin(theta)
    ca, sa = np.cos(alpha), np.sin(alpha)
    return np.array([
        [ct, -st*ca,  st*sa, a*ct],
        [st,  ct*ca, -ct*sa, a*st],
        [0,     sa,    ca,    d ],
        [0,      0,     0,    1 ],
    ])

# ตาราง DH ของแขน 3 DOF (ใช้ค่าจริงจากโปรเจกต์)
dh = [
    {"a": 0,   "alpha": np.deg2rad(-90), "d": 156.5, "theta": np.deg2rad(30)},
    {"a": 135, "alpha": 0,               "d": 0,     "theta": np.deg2rad(45)},
    {"a": 157, "alpha": 0,               "d": 0,     "theta": np.deg2rad(-20)},
]

T = np.eye(4)
for joint in dh:
    T = T @ dh_transform(**joint)

print("ตำแหน่งปลายแขน (x, y, z):", T[:3, 3])

รูป: แผนภาพการเดินสายไฟ — ESP32 → A4988 ×3 → NEMA 17 ×3 + Servo Gripper + แหล่งจ่ายไฟ (GND ต้องต่อร่วมกันทุกบอร์ด)

🔗 ตารางขา GPIO (จากโค้ดจริง)

🌐 หน้าเว็บควบคุมบน ESP32

แขนกลมี Web Server ในตัว (พอร์ต 80) เข้าใช้งานผ่านเบราว์เซอร์ที่ http://[IP-ESP32]/ ประกอบด้วยโหมด:

การเคลื่อนที่ใช้ Trajectory Planning — สร้างจุดขั้นกลาง (interpolation) แล้วป้อนเข้าคิวคำสั่ง commandQueue เพื่อให้ข้อต่อทั้ง 3 ขยับพร้อมกันอย่างนุ่มนวล

🧠 ขั้นตอนติดตั้ง Ollama (Local AI บนเครื่อง)

1. ดาวน์โหลดและติดตั้ง Ollama จากเว็บไซต์
2. เปิด Terminal แล้วโหลดโมเดลภาษาไทย: ollama pull typhoon-instruct (หรือ qwen2.5 / gemma2)
3. ทดสอบ: ollama run typhoon-instruct "สวัสดี"
4. เชื่อมคอมพิวเตอร์กับ Wi-Fi เดียวกับ ESP32 (หรือให้ ESP32 ต่อ AP เดียวกัน)

� ขั้นตอนการทำงาน AI → แขนกล

รูป: AI ตีความคำสั่งภาษาไทย → แปลงเป็น JSON → ส่งผ่าน Wi-Fi → ESP32 ขยับแขนกลทำงาน

�🐍 โค้ดตัวอย่าง: “หยิบกระป๋องสีแดงไปทิ้ง”

import requests, subprocess, json, re

ESP32 = "http://192.168.1.100"     # IP ของแขนกล

def ask_ai(prompt):
    r = subprocess.run(["ollama", "run", "typhoon-instruct", prompt],
                       capture_output=True, text=True)
    return r.stdout.strip()

# 1) ให้ AI แปลงคำสั่งภาษาคน → JSON พิกัด
text = "หยิบกระป๋องสีแดงไปทิ้ง"
prompt = f"""แขนกล 3DOF ทำงานบนพื้นที่ x=0..300, y=0..400, z=0..250 มม.
กระป๋องสีแดงอยู่ที่ x=100,y=100,z=50 และถังขยะอยู่ที่ x=250,y=250,z=50
ตอบเป็น JSON เดียวเท่านั้น: {{"x":..,"y":..,"z":..,"gripper":0}}   (gripper 0=คีบ 180=ปล่อย)
คำสั่ง: {text}"""
out = ask_ai(prompt)

# 2) แยก JSON ออกจากคำตอบ แล้วส่งไปแขนกล
m = re.search(r'\{.*\}', out, re.S)
data = json.loads(m.group(0))
print("🤖 AI ตีความได้:", data)

# 3) สั่งแขนกลทำงาน
requests.post(f"{ESP32}/api/move", data={"x": data["x"], "y": data["y"], "z": data["z"]})
requests.post(f"{ESP32}/api/gripper", data={"position": data["gripper"]})
print("✅ แขนกลทำงานตามคำสั่ง AI แล้ว!")

👁️ ระดับถัดไป: ให้แขนกล “มองเห็น” ด้วย VLM / VLA

นอกจาก AI ที่ “ฟังคำสั่ง” แล้ว เรายังเพิ่ม AI ที่ “มองเห็น” ได้ — ใช้กล้องเว็บแคม (Webcam) + โมเดล Vision Language Model (VLM) ให้แขนกลหาตำแหน่งชิ้นงานจากภาพได้เอง โดยไม่ต้องบอกพิกัดล่วงหน้า

• VLM (Vision–Language Model) — โมเดลที่เข้าใจทั้งภาพและข้อความ เช่น qwen3-vl, minicpm-v4.5, llava (รันผ่าน Ollama ได้เลย) — ถามได้ว่า “กระป๋องสีแดงอยู่ตรงไหนในภาพ?” แล้วได้พิกัดพิกเซลกลับมา
• VLA (Vision–Language–Action) — โมเดลหุ่นยนต์แบบ End-to-End (เช่น OpenVLA, RT-2, π0) ที่รับภาพ + คำสั่ง แล้วออกการเคลื่อนที่ของมอเตอร์โดยตรง — ยังเป็นงานวิจัยขั้นสูง เหมาะสำหรับผู้เรียนที่อยากต่อยอด

สถาปัตยกรรมที่แนะนำสำหรับค่าย: กล้อง → VLM หาตำแหน่งชิ้นงาน → แปลงพิกเซลเป็นพิกัด X, Y, Z → ส่ง /api/move (ใช้ IK ที่เรียนมาแล้ว — เหมาะกับงานจริงและปลอดภัยกว่า VLA แบบเต็มรูปแบบ)

รูป: แขนกลมองเห็นด้วย VLM — กล้องจับภาพ → โมเดลหาตำแหน่ง → แปลงพิกัด → สั่งแขนกล

🐍 โค้ดตัวอย่าง: “มองเห็นกระป๋องแดงแล้วหยิบ”

import requests, base64, json, re, cv2

# 1) ถ่ายภาพจากกล้องเว็บแคม (OpenCV)
cap = cv2.VideoCapture(0)
ok, frame = cap.read()
cap.release()
_, buf = cv2.imencode(".jpg", frame)
b64 = base64.b64encode(buf).decode()

# 2) ถาม VLM ผ่าน Ollama API ให้หาตำแหน่งกระป๋องในภาพ
r = requests.post("http://localhost:11434/api/generate", json={
    "model": "qwen3-vl",   # หรือ minicpm-v4.5 / llava
    "prompt": 'ในภาพนี้มีกระป๋องสีแดง 1 ใบ '
              'ตอบเป็น JSON: {"x_px":..,"y_px":..} (กึ่งกลางวัตถุเป็นพิกเซล)',
    "images": [b64],
    "stream": False,
})
out = r.json()["response"]
m = re.search(r'\{.*\}', out, re.S)
px = json.loads(m.group(0))
print("📍 VLM เห็นชิ้นงานที่พิกเซล:", px)

# 3) แปลงพิกเซล -> พิกัดแขนกล (ต้องคาลิเบรตกล้องก่อน) แล้วสั่งงาน
x = int(px["x_px"] * 0.5)          # ตัวอย่างการแมปพิกัด
y, z = 300, 80
requests.post("http://192.168.1.100/api/move", data={"x": x, "y": y, "z": z})
print("✅ แขนกลเคลื่อนไปหยิบชิ้นงานที่มองเห็น")

🧠 RL เบื้องต้นใน 1 นาที

🛡️ ทำไมต้องเทรนใน Simulator ก่อน (Sim-to-Real)

⚖️ เปรียบเทียบ MuJoCo vs Isaac Sim — เลือกใช้ตัวไหน?

🚀 ต่อยอดกับแขนกลของค่าย

1. สร้างโมเดลแขนกลใน Onshape → Export เป็น URDF (หรือใช้ปลั๊กอิน Onshape-to-URDF)
2. โหลดเข้า MuJoCo (เบา เริ่มต้นเร็ว) หรือ Isaac Sim (สมจริง) เพื่อทดสอบฟิสิกส์
3. นิยาม Reward: “เข้าใกล้เป้า / คีบจับสำเร็จ = +” “ชนพื้น / เกินขอบเขต = −”
4. เทรนด้วย PPO จนได้ Policy ที่คีบ–วางชิ้นงานได้
5. Export Policy แล้วนำไปรันบน ESP32 (หรือคอมพิวเตอร์) สั่งผ่าน /api/move ที่มีอยู่แล้ว

📘 การตั้งค่า PPO Policy สำหรับแขนกล 3DOF

เจาะลึกการตั้งค่า PPO ที่สำคัญ — Actor–Critic, Runner, Algorithm, Observation/Action Space และ Distillation — อธิบายทีละพารามิเตอร์ พร้อมค่าที่แนะนำสำหรับแขนกลของเรา:

ค่าที่แนะนำสำหรับแขนกล 3DOF (terk_arm):

obs    = [θ1, θ2, θ3, gripper, target_x, target_y, target_z]   (7)
action = [Δθ1, Δθ2, Δθ3, gripper]                                (4)
actor_hidden_dims = [128, 64]   critic_hidden_dims = [128, 64]
clip_param = 0.2   entropy_coef = 0.005   init_noise_std = 1.0

📱 แชร์เว็บสื่อการสอนนี้

สแกน QR ด้านล่างเพื่อเปิดเว็บไซต์บนมือถือ — แชร์ให้เพื่อน หรือพิมพ์ติดห้องเรียนได้เลย