קורס רובוטיקה ובינה מלאכותית 01-RB302 מבוא MuJoCo

מטרה : היכרות מנוע פיזיקלי לצורך סימולציה של רובוטים.

MuJoCo – Advanced physics simulation

MuJoCo הוא אחד ממנועי הסימולציה הפיזיקלית המובילים במחקר רובוטיקה, בקרה ובינה מלאכותית. הוא מפותח ומתוחזק על ידי Google DeepMind ומופץ בחינם בקוד פתוח.

MuJoCo הם ראשי תיבות של Multi-Joint Dynamics with Contact — דינמיקה של מערכות מרובות מפרקים עם מגע והתנגשויות.

בניגוד לתוכנת תלת־ממד רגילה, MuJoCo מחשב כיצד מערכות פיזיקליות מתנהגות תחת כוחות אמיתיים במודל: כבידה, מסה, מומנטים, חיכוך, התנגשויות ותנועת מפרקים.

1. מה אפשר לעשות עם MuJoCo?

תחום	דוגמאות לשימוש
זרועות רובוטיות	אחיזה, הרמה, העברת חפצים, חישובי מומנט
רובוטים הולכים	כלב רובוטי עולה במדרגות, רץ ומתגבר על מכשולים
רובוטים דמויי אדם	הליכה, שיווי משקל, נפילה והתאוששות
רחפנים	תנועת גוף, כוחות, בקרת טיסה ורוח עם מודל מתאים
פיזיקה של גופים	כדור קופץ על בטון, התנגשות, חיכוך והעברת אנרגיה
מכונות ומנגנונים	גלגלי שיניים בקירוב מתאים, מנופים, קפיצים ומערכות מפרקים
AI ו־Reinforcement Learning	אימון רובוט ללמוד פעולות בניסוי וטעייה
ביומכניקה	שרירים, גידים, מפרקים ותנועה אנושית
בקרה הנדסית	PID, בקרת מומנט, MPC ואופטימיזציה

2. דוגמאות לפרויקטים אמיתיים

Model Gallery - MuJoCo Documentation

כלב רובוטי – אימון AI

הרובוט לומד ללכת, להסתובב, לקפוץ ולעלות במדרגות. אפשר לאמן מדיניות RL בסימולציה ולהעבירה בהמשך לרובוט אמיתי, לאחר בדיקות והתאמות.

Pick And Place - Gymnasium-Robotics Documentation

זרוע רובוטית – Pick and Place

זרוע בעלת שישה צירים מזהה קובייה, ניגשת אליה, תופסת ומעבירה אותה. המנוע מחשב כוחות מגע, מומנטים ותנועות.

SimBenchmark | Physics engine benchmark for robotics applications: RaiSim vs. Bullet vs. ODE vs. MuJoCo vs. DartSim

ניסוי פיזיקלי – כדורסל נופל

משחררים כדור מגובה 10 מטרים, מגדירים מסה, חיכוך, תכונות מגע וכוחות רוח, ובוחנים גובה קפיצה, מהירות ואנרגיה לאורך הזמן.

חשוב להבין: MuJoCo מחשב את הפיזיקה בהתאם למודל שהגדרת. הוא אינו מבטיח דיוק ניסויי ללא כיול פרמטרים מול מדידות אמיתיות.

3. מי משתמש ב־MuJoCo בעולם הרובוטיקה?

צריך להבחין בין גוף שמפתח או משתמש ב־MuJoCo במחקר, לבין יצרן רובוטים שיש עבורו מודל סימולציה.

חברה / ארגון	קשר ל־MuJoCo
Google DeepMind	מתחזקת ומפתחת

4. אילו מערכות תומכות ב־MuJoCo?

מערכת	תמיכה
Python	תמיכה רשמית מלאה
C / C++	API מקורי ב־C
Windows	כן
Linux	כן
macOS	כן
ROS 2	כן, דרך `mujoco_ros2_control`
URDF	טעינה, עם מגבלות תאימות
MJCF	פורמט מודלים מקורי
Gymnasium / RL	אינטגרציה לאימון AI
JAX / MJX	חישוב מקביל מואץ
Unity	פלאגין רשמי

האם MuJoCo מתאים לפיתוח הרובוטים שלך?

בהחלט, במיוחד לזרועות רובוטיות, רובוטים הולכים ואימון AI באמצעות Reinforcement Learning.

סימולציה של דינמיקה ומפרקים מצוין

אימון רובוטים ב־RL מצוין

התנגשויות וחיכוך מצוין

מצלמות וראייה ממוחשבת טוב

רחפנים ואווירודינמיקה דורש מודלים נוספים

מיקרורובוטיקה עם זרימת נוזלים מוגבל

המסקנה: MuJoCo הוא בחירה חזקה במיוחד כאשר המטרה היא להבין את הפיזיקה של הרובוט, לפתח בקר מתקדם ולאמן AI לפני הפעלת הרובוט האמיתי. לעומת זאת, סימולציה מפורטת של נוזלים, אווירודינמיקה או אלקטרוניקה דורשת לרוב כלים משלימים

חלק א : תרגול מנוע פיזיקאלי – MuJoCo

דוגמה: כדורסל במסה 0.62 ק״ג בגובה 10 מטר

בתחילת הנפילה, כשהכדור במנוחה:

\[ E_p=0.62\times9.81\times10=\boxed{60.82\ J} \]

\[ E_k=0 \]

בהזנחת התנגדות אוויר, רגע לפני הפגיעה בקרקע:

\[ E_k\approx60.82\ J \]

חשוב: בסימולציית MuJoCo עם רוח, חיכוך ופגיעות בקרקע, האנרגיה המכנית אינה בהכרח נשמרת. בנוסף, אם הכדור מסתובב, יש לכלול גם אנרגיה קינטית סיבובית.

התוכנה מדמה נפילה וקפיצה של כדורסל מגובה 10 מטרים, באמצעות מנוע הפיזיקה MuJoCo.

מה התוכנה עושה?

סימולציה תלת־ממדית — כדורסל נופל, פוגע בקרקע וקופץ בחזרה.
כבידה — מחשבת תאוצה של ‎9.81 m/s².
רוח — מפעילה רוח של 5 מטר לשנייה בציר X ו־2.7 מטר לשנייה בציר Y.
סוג כדור — מאפשרת לבחור כדורסל, כדור טניס, כדור גומי או כדור פלדה.
סוג קרקע — מאפשרת להגדיר בטון, גומי או ספוג באמצעות פרמטרים פיזיקליים שונים.
זיהוי התנגשויות — מזהה פגיעה בקרקע ומחשב כוחות מגע.
מדידת קפיצות — מזהה את הגובה המרבי לאחר כל קפיצה.
חישוב אנרגיות — אנרגיה פוטנציאלית, קינטית וסכומן.
חישוב תנע ומהירות — בכל שלושת הצירים.
גרפים בזמן אמת — מציגה אנרגיות, מיקום ומהירות לאורך הסימולציה.

נריץ את הקוד

1. פרמטרים של הסביבה והפיזיקה

Parameter (English)	שם בעברית	ערך נוכחי	טווח מומלץ	דוגמה והשפעה
`DROP_HEIGHT`	גובה תחילת הנפילה	10 m	0.5–100 m	20: זמן נפילה ארוך יותר
`GRAVITY`	תאוצת הכובד	9.81 m/s²	0–20	1.62: כבידה של הירח
`WIND_VECTOR[0]`	רוח בציר X	5 m/s	‎−30 עד 30	‎−5: רוח לכיוון X השלילי
`WIND_VECTOR[1]`	רוח בציר Y	2.7 m/s	‎−30 עד 30	10: רוח חזקה לכיוון Y
`WIND_VECTOR[2]`	רוח בציר Z	0 m/s	‎−20 עד 20	5: זרימת אוויר כלפי מעלה
`density`	צפיפות האוויר	1.2 kg/m³	0–2	0: ביטול כוח הגרר התלוי בצפיפות
`viscosity`	צמיגות האוויר	0	0–0.001 Pa·s	0.000018: בקירוב צמיגות האוויר
`DT`	משך צעד פיזיקלי	0.001 s	0.0001–0.005 s	0.0005: חישוב כל חצי מילישנייה
`SIM_TIME`	משך הסימולציה	20 s	1–120 s	60: סימולציה של דקה

2. פרמטרים של הכדור

בקוד הנוכחי אפשר לבחור ארבעה סוגי כדורים באמצעות BALL_TYPE.

Parameter (English)	שם בעברית	ערך נוכחי	טווח / אפשרויות	דוגמה
`BALL_TYPE`	סוג הכדור	basketball	basketball, tennis, rubber, steel	tennis: כדור טניס
`radius`	רדיוס הכדור	0.12 m	0.01–0.5 m	0.05: כדור בקוטר 10 ס״מ
`mass`	מסת הכדור	0.62 kg	0.01–10 kg	2: כדור כבד יותר
`ball_color`	צבע הכדור	כתום	RGBA	אדום, ירוק, כחול
`geom type`	צורת הגוף	sphere	sphere בקוד הנוכחי	אפשר להרחיב לקובייה וגליל

סוגי כדורים שכבר מוגדרים בתוכנה

סוג הכדור	רדיוס	מסה
Basketball — כדורסל	12 cm	0.62 kg
Tennis — טניס	3.35 cm	0.057 kg
Rubber — גומי	10 cm	0.50 kg
Steel — פלדה	5 cm	4.10 kg

חשוב: כרגע בחירת סוג הכדור משנה רק את המסה, הגודל והצבע. עדיין לא הגדרנו לכל סוג כדור מקדם אלסטיות או גרר ייחודי.

3. פרמטרים של הקרקע וההתנגשות

אלה הפרמטרים המשמעותיים ביותר לצורך שליטה בגובה הקפיצה בחזרה.

Parameter (English)	שם בעברית	ערך נוכחי — בטון	טווח ניסוי מומלץ	דוגמה והשפעה
`GROUND_TYPE`	סוג הקרקע	concrete	concrete, rubber, foam	foam: משטח רך
`stiffness`	קשיחות מגע	15,000	1,000–100,000	30,000: מגע קשיח יותר
`damping`	ריסון מגע	15	0–200	50: ריסון חזק יותר
`friction[0]`	חיכוך החלקה בכיוון ראשון	0.8	0–2	0.1: משטח חלק
`friction[1]`	חיכוך החלקה בכיוון שני	0.005	0–2	0.8: חיכוך דומה בשני הכיוונים
`friction[2]`	חיכוך פיתול	0.0001	0–0.1	0.01: התנגדות גדולה יותר לפיתול
`friction[3:5]`	חיכוך גלגול	0.0001, 0.0001	0–0.1	0.01: התנגדות גדולה יותר לגלגול
`condim`	ממדי אילוץ המגע	3	1, 3, 4, 6	6: כולל גם חיכוך גלגול
`solimp`	עקומת אימפדנס המגע	0.95, 0.99, 0.001	תלוי בפרמטר	משנה את תגובת אילוץ המגע
`ground_color`	צבע הקרקע	אפור	RGBA	ירוק עבור ספוג

הבהרה חשובה: בפרמטר friction של זוג מגע, שני הערכים הראשונים מייצגים חיכוך החלקה. אבל כאשר condim=3, לא כל רכיבי הפיתול והגלגול פעילים. בנוסף, הערכים stiffness ו־damping הם פרמטרים נומריים של פותר המגע, ולא מדידות ישירות של החומר.

MuJoCo Documentation

ערכי המשטחים המוגדרים בקוד

קרקע	Stiffness	Damping	צבע
Concrete — בטון	15,000	15	אפור
Rubber — גומי	8,000	20	שחור
Foam — ספוג	1,500	55	ירוק

4. פרמטרים של התצוגה והגרפים

Parameter (English)	שם בעברית	ערך נוכחי	טווח מומלץ
`GRAPH_INTERVAL`	זמן בין עדכוני גרף	0.10 s	0.02–1 s
`VIEW_INTERVAL`	זמן בין עדכוני תלת־ממד	0.02 s	0.01–0.1 s
`PRINT_INTERVAL`	תדירות הדפסה בטרמינל	0.20 s	0.05–2 s
`left_w`	רוחב חלון MuJoCo	58%	40%–80%
`viewer.cam.distance`	מרחק המצלמה	23	2–100
`viewer.cam.azimuth`	זווית אופקית של המצלמה	135°	0°–360°
`viewer.cam.elevation`	זווית אנכית של המצלמה	‎−15°	בקירוב ‎−89° עד 89°
`WIND_VECTOR * 0.5`	קנה מידה של חץ הרוח	0.5	0.1–3

5. פרמטרים נוספים שכדאי להוסיף לתוכנה

הפרמטרים הבאים עדיין אינם קיימים כמשתני הגדרה עצמאיים בקוד:

Parameter (English)	שם בעברית	דוגמה	למה כדאי להוסיף
`restitution`	מקדם החזרה אלסטית	0.8	לקבוע יעד לגובה הקפיצה באמצעות כיול
`drag_coefficient`	מקדם גרר אווירודינמי	0.47	לתאר התנגדות אוויר של כדור
`spin`	סיבוב עצמי	20 rad/s	לחקור השפעת סיבוב
`initial_velocity`	מהירות התחלתית	(2, 0, 0) m/s	לדמות זריקת כדור
`ground_angle`	זווית הקרקע	15°	לדמות משטח משופע
`wind_variation`	שינוי רוח בזמן	2 Hz	לדמות משבי רוח
`ball_pressure`	לחץ אוויר פנימי בכדור	8 psi	לכייל שינוי קשיחות וקפיצה

לחץ פנימי ומקדם החזרה אינם פרמטרי חומר אוטומטיים במודל הכדור הקשיח הנוכחי; נצטרך להגדיר מודל או תהליך כיול עבורם.

מבחינה מדעית:אפשר להשתמש בתוכנה כדי לחקור השפעות של מסת הכדור, גודלו, הרוח, סוג המשטח ופרמטרי המגע על מסלול הנפילה, הכוחות וגובה הקפיצה. לקבלת תוצאות מדויקות בעולם האמיתי נדרש כיול של מודל המגע והאוויר.

pip install mujoco numpy matplotlib pywin32

1	pip install mujoco numpy matplotlib pywin32

import os
import time
import ctypes
import time



import numpy as np
import matplotlib

# Use Tk so plots can update without
# repeatedly activating their window.
matplotlib.use("TkAgg")

import matplotlib.pyplot as plt
import mujoco
import mujoco.viewer

import win32gui
import win32con
import win32process


# ==========================================
# 1. USER SETTINGS
# ==========================================

BALL_TYPE = "basketball"
GROUND_TYPE = "concrete"

DROP_HEIGHT = 10.0
GRAVITY = 9.81

# Wind velocity (m/s)
WIND_VECTOR = np.array([5.0, 2.7, 0.0])

DT = 0.001
SIM_TIME = 20.0

GRAPH_INTERVAL = 0.10
VIEW_INTERVAL = 0.02
PRINT_INTERVAL = 0.20

# ==========================================
# 2. BALL AND GROUND PROPERTIES
# ==========================================

BALLS = {
    "basketball": (0.12, 0.62, "1 0.42 0.05 1"),
    "tennis":     (0.0335, 0.057, "0.8 1 0.1 1"),
    "rubber":     (0.10, 0.50, "1 0.1 0.1 1"),
    "steel":      (0.05, 4.10, "0.7 0.7 0.8 1")
}

# Illustrative presets, not calibrated
# real-world material properties.
GROUNDS = {
    "concrete": (15000, 15, "0.6 0.6 0.6 1"),
    "rubber":   (8000, 20, "0.15 0.15 0.15 1"),
    "foam":     (1500, 55, "0.2 0.7 0.2 1")
}

radius, mass, ball_color = BALLS[BALL_TYPE]
stiffness, damping, ground_color = GROUNDS[GROUND_TYPE]


# ==========================================
# 3. WINDOWS LAYOUT
# ==========================================

# Enables accurate window dimensions
# on displays with Windows scaling.
try:
    ctypes.windll.user32.SetProcessDPIAware()
except Exception:
    pass

screen_w = ctypes.windll.user32.GetSystemMetrics(0)
screen_h = ctypes.windll.user32.GetSystemMetrics(1)

# 58% of the screen for MuJoCo.
left_w = int(screen_w * 0.58)
right_w = screen_w - left_w

window_h = screen_h - 75

GRAPH_TITLE = "LIVE PHYSICS GRAPHS"


def find_mujoco_window():
    """Locate the MuJoCo viewer window."""
    matches = []
    current_pid = os.getpid()

    def callback(hwnd, _):
        if not win32gui.IsWindowVisible(hwnd):
            return

        _, pid = win32process.GetWindowThreadProcessId(hwnd)

        if pid != current_pid:
            return

        title = win32gui.GetWindowText(hwnd)
        text = title.lower()

        if "mujoco" in text or "simulate" in text:
            matches.append(hwnd)

    win32gui.EnumWindows(callback, None)

    return matches[0] if matches else None


def arrange_windows(graph_hwnd):
    """Place simulation left and graphs right."""

    # Graphs behind the simulation.
    if graph_hwnd:
        win32gui.SetWindowPos(
            graph_hwnd,
            win32con.HWND_NOTOPMOST,
            left_w, 0,
            right_w, window_h,
            win32con.SWP_NOACTIVATE |
            win32con.SWP_SHOWWINDOW
        )

    sim_hwnd = find_mujoco_window()

    if sim_hwnd:
        win32gui.SetWindowPos(
            sim_hwnd,
            win32con.HWND_TOP,
            0, 0,
            left_w, window_h,
            win32con.SWP_SHOWWINDOW
        )
        return True

    return False


# ==========================================
# 4. MUJOCO MODEL
# ==========================================

xml = f"""
<mujoco model="Basketball Wind Simulation">

    <option timestep="{DT}"
            gravity="0 0 -{GRAVITY}"
            wind="{WIND_VECTOR[0]} {WIND_VECTOR[1]} {WIND_VECTOR[2]}"
            density="1.2"
            viscosity="0"/>

    <worldbody>

        <light pos="0 -5 15" dir="0 0 -1"/>

        <geom name="ground"
              type="plane"
              size="30 30 0.1"
              rgba="{ground_color}"/>

        <body name="ball"
              pos="0 0 {DROP_HEIGHT}">

            <freejoint/>

            <geom name="ball_geom"
                  type="sphere"
                  size="{radius}"
                  mass="{mass}"
                  rgba="{ball_color}"/>

        </body>

    </worldbody>

    <contact>
        <pair geom1="ground"
              geom2="ball_geom"
              condim="3"
              friction="0.8 0.005 0.0001 0.0001 0.0001"
              solref="-{stiffness} -{damping}"
              solimp="0.95 0.99 0.001"/>
    </contact>

</mujoco>
"""

model = mujoco.MjModel.from_xml_string(xml)
data = mujoco.MjData(model)

ball_id = model.body("ball").id
ball_geom_id = model.geom("ball_geom").id
ground_id = model.geom("ground").id


# ==========================================
# 5. PHYSICS DATA
# ==========================================

times = []
positions = []
velocities = []
energies = []

bounce_count = 0
rebound_heights = []


def physics():

    pos = data.xipos[ball_id].copy()

    # For this single free-joint body,
    # translational qvel occupies [0:3].
    vel = data.qvel[:3].copy()

    momentum = mass * vel

    ep = mass * GRAVITY * pos[2]

    # Translational kinetic energy.
    ek = 0.5 * mass * np.dot(vel, vel)

    et = ep + ek

    return pos, vel, momentum, ep, ek, et


def record():

    pos, vel, p, ep, ek, et = physics()

    times.append(data.time)
    positions.append(pos)
    velocities.append(vel)
    energies.append([ep, ek, et])


# ==========================================
# 6. CREATE LIVE GRAPHS
# ==========================================

plt.ion()

fig, axes = plt.subplots(
    3, 1,
    figsize=(7, 9),
    sharex=True
)

fig.canvas.manager.set_window_title(GRAPH_TITLE)

ax_e, ax_p, ax_v = axes

fig.suptitle(
    f"{BALL_TYPE.upper()} / {GROUND_TYPE.upper()}\n"
    f"Wind X={WIND_VECTOR[0]}, "
    f"Y={WIND_VECTOR[1]} m/s"
)

# Energy lines
le1, = ax_e.plot([], [], label="Potential")
le2, = ax_e.plot([], [], label="Kinetic")
le3, = ax_e.plot([], [], label="Total")

ax_e.set_title("Energy")
ax_e.set_ylabel("Joules")
ax_e.legend(loc="upper right")
ax_e.grid(True)

# Position lines
lp1, = ax_p.plot([], [], label="X")
lp2, = ax_p.plot([], [], label="Y")
lp3, = ax_p.plot([], [], label="Z")

ax_p.set_title("Position")
ax_p.set_ylabel("Meters")
ax_p.legend(loc="upper right")
ax_p.grid(True)

# Velocity lines
lv1, = ax_v.plot([], [], label="Vx")
lv2, = ax_v.plot([], [], label="Vy")
lv3, = ax_v.plot([], [], label="Vz")

ax_v.set_title("Velocity")
ax_v.set_xlabel("Time (s)")
ax_v.set_ylabel("m/s")
ax_v.legend(loc="upper right")
ax_v.grid(True)

fig.tight_layout()

plt.show(block=False)

# Complete initial window creation.
fig.canvas.draw()
fig.canvas.flush_events()

graph_hwnd = win32gui.FindWindow(None, GRAPH_TITLE)


def update_graphs():

    t = np.asarray(times)
    p = np.asarray(positions)
    v = np.asarray(velocities)
    e = np.asarray(energies)

    if len(t) == 0:
        return

    le1.set_data(t, e[:, 0])
    le2.set_data(t, e[:, 1])
    le3.set_data(t, e[:, 2])

    lp1.set_data(t, p[:, 0])
    lp2.set_data(t, p[:, 1])
    lp3.set_data(t, p[:, 2])

    lv1.set_data(t, v[:, 0])
    lv2.set_data(t, v[:, 1])
    lv3.set_data(t, v[:, 2])

    for ax in axes:
        ax.relim()
        ax.autoscale_view()
        ax.set_xlim(0, max(2, data.time + 0.2))

    # Update without calling plt.pause(),
    # which can change window focus.
    fig.canvas.draw_idle()
    fig.canvas.flush_events()


# ==========================================
# 7. DRAW WIND VECTOR IN 3D
# ==========================================

def draw_wind(viewer):

    scene = viewer.user_scn
    scene.ngeom = 0

    if scene.maxgeom < 1:
        return

    if np.linalg.norm(WIND_VECTOR) < 1e-9:
        return

    start = np.array([-3.0, -2.0, 8.0])
    end = start + WIND_VECTOR * 0.5

    geom = scene.geoms[0]

    mujoco.mjv_initGeom(
        geom,
        mujoco.mjtGeom.mjGEOM_ARROW,
        np.zeros(3),
        np.zeros(3),
        np.eye(3).flatten(),
        np.array([0.1, 0.4, 1, 1],
                 dtype=np.float32)
    )

    mujoco.mjv_connector(
        geom,
        mujoco.mjtGeom.mjGEOM_ARROW,
        0.08,
        start,
        end
    )

    scene.ngeom = 1


# ==========================================
# 8. COLLISION DETECTION
# ==========================================

def detect_collision():

    for i in range(data.ncon):

        c = data.contact[i]

        if {c.geom1, c.geom2} != {
            ground_id, ball_geom_id
        }:
            continue

        force = np.zeros(6)

        mujoco.mj_contactForce(
            model, data, i, force
        )

        if force[0] > 1e-8:
            return i, force[0]

    return None, 0.0


def collision_callback(index, force, old_vel):

    c = data.contact[index]

    print("\n========== COLLISION ==========")
    print(f"Time: {data.time:.4f} s")
    print(f"Ball: {BALL_TYPE}")
    print(f"Ground: {GROUND_TYPE}")
    print(f"Contact XYZ: {np.round(c.pos, 3)}")
    print(f"Previous velocity: {np.round(old_vel, 3)}")
    print(f"Normal force: {force:.2f} N")
    print("================================\n")


# ==========================================
# 9. TERMINAL PHYSICS
# ==========================================

def print_status():

    pos, vel, p, ep, ek, et = physics()

    print(
        f"t={data.time:6.3f} | "
        f"XYZ={np.round(pos, 3)} | "
        f"V={np.round(vel, 3)}"
    )

    print(
        f"Momentum={np.round(p, 3)} | "
        f"Epot={ep:7.2f} J | "
        f"Ekin={ek:7.2f} J | "
        f"Etotal={et:7.2f} J"
    )


# ==========================================
# 10. MAIN SIMULATION
# ==========================================

def main():

    global bounce_count

    print("\nMUJOCO LIVE PHYSICS")
    print("Ball:", BALL_TYPE)
    print("Mass:", mass, "kg")
    print("Diameter:", radius * 2, "m")
    print("Ground:", GROUND_TYPE)
    print("Wind:", WIND_VECTOR, "m/s")
    print("Timestep:", DT, "s\n")

    record()
    print_status()

    graph_steps = max(1, round(GRAPH_INTERVAL / DT))
    view_steps = max(1, round(VIEW_INTERVAL / DT))
    print_steps = max(1, round(PRINT_INTERVAL / DT))

    step = 0
    was_touching = False
    tracking_rebound = False

    with mujoco.viewer.launch_passive(
        model,
        data,
        show_left_ui=False,
        show_right_ui=False
    ) as viewer:

        with viewer.lock():
            viewer.cam.lookat[:] = [0, 0, 5]
            viewer.cam.distance = 23
            viewer.cam.azimuth = 135
            viewer.cam.elevation = -15

        viewer.sync()

        # Position MuJoCo left,
        # graphs right and behind.
        arrange_windows(graph_hwnd)

        wall_start = time.perf_counter()
        print("Program started...")

         # This line adds the 3-second delay
        time.sleep(3)
        # Set camera.
        while (
            viewer.is_running()
            and data.time < SIM_TIME
        ):

            if not plt.fignum_exists(fig.number):
                break

            old_vel = data.qvel[:3].copy()
            old_vz = data.qvel[2]

            # Physics step: 1 ms
            mujoco.mj_step(model, data)
            step += 1

            record()

            # Contact check
            ci, force = detect_collision()
            touching = ci is not None

            if touching and not was_touching:
                bounce_count += 1

                print(
                    f"\nBOUNCE CONTACT {bounce_count}"
                )

                collision_callback(
                    ci, force, old_vel
                )

            if was_touching and not touching:
                tracking_rebound = True

            # Detect highest rebound point
            vz = data.qvel[2]

            if (
                tracking_rebound
                and not touching
                and old_vz > 0
                and vz <= 0
            ):
                height = data.xipos[ball_id, 2]

                rebound_heights.append(height)

                print(
                    f"REBOUND HEIGHT: {height:.3f} m"
                )

                tracking_rebound = False

            was_touching = touching

            # Update MuJoCo viewer.
            if step % view_steps == 0:

                with viewer.lock():
                    draw_wind(viewer)

                viewer.sync()

            # Update graphs behind viewer.
            if step % graph_steps == 0:
                update_graphs()

            # Terminal output.
            if step % print_steps == 0:
                print_status()

            # Approximate real-time speed.
            target = wall_start + data.time
            remaining = target - time.perf_counter()

            if remaining > 0:
                time.sleep(remaining)

    # =====================================
    # 11. RESULTS
    # =====================================

    print("\nSIMULATION COMPLETE")
    print("Collision events:", bounce_count)

    for i, h in enumerate(rebound_heights, 1):
        print(f"Rebound {i}: {h:.3f} m")

    if plt.fignum_exists(fig.number):
        update_graphs()
        plt.ioff()
        plt.show()


if __name__ == "__main__":
    main()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

import os

import time

import ctypes

import time

import numpy as np

import matplotlib

# Use Tk so plots can update without

# repeatedly activating their window.

matplotlib.use("TkAgg")

import matplotlib.pyplot as plt

import mujoco

import mujoco.viewer

import win32gui

import win32con

import win32process

# ==========================================

# 1. USER SETTINGS

# ==========================================

BALL_TYPE = "basketball"

GROUND_TYPE = "concrete"

DROP_HEIGHT = 10.0

GRAVITY = 9.81

# Wind velocity (m/s)

WIND_VECTOR = np.array([5.0, 2.7, 0.0])

DT = 0.001

SIM_TIME = 20.0

GRAPH_INTERVAL = 0.10

VIEW_INTERVAL = 0.02

PRINT_INTERVAL = 0.20

# ==========================================

# 2. BALL AND GROUND PROPERTIES

# ==========================================

BALLS = {

"basketball": (0.12, 0.62, "1 0.42 0.05 1"),

"tennis": (0.0335, 0.057, "0.8 1 0.1 1"),

"rubber": (0.10, 0.50, "1 0.1 0.1 1"),

"steel": (0.05, 4.10, "0.7 0.7 0.8 1")

}

# Illustrative presets, not calibrated

# real-world material properties.

GROUNDS = {

"concrete": (15000, 15, "0.6 0.6 0.6 1"),

"rubber": (8000, 20, "0.15 0.15 0.15 1"),

"foam": (1500, 55, "0.2 0.7 0.2 1")

}

radius, mass, ball_color = BALLS[BALL_TYPE]

stiffness, damping, ground_color = GROUNDS[GROUND_TYPE]

# ==========================================

# 3. WINDOWS LAYOUT

# ==========================================

# Enables accurate window dimensions

# on displays with Windows scaling.

try:

ctypes.windll.user32.SetProcessDPIAware()

except Exception:

pass

screen_w = ctypes.windll.user32.GetSystemMetrics(0)

screen_h = ctypes.windll.user32.GetSystemMetrics(1)

# 58% of the screen for MuJoCo.

left_w = int(screen_w * 0.58)

right_w = screen_w - left_w

window_h = screen_h - 75

GRAPH_TITLE = "LIVE PHYSICS GRAPHS"

def find_mujoco_window():

"""Locate the MuJoCo viewer window."""

matches = []

current_pid = os.getpid()

def callback(hwnd, _):

if not win32gui.IsWindowVisible(hwnd):

return

_, pid = win32process.GetWindowThreadProcessId(hwnd)

if pid != current_pid:

return

title = win32gui.GetWindowText(hwnd)

text = title.lower()

if "mujoco" in text or "simulate" in text:

matches.append(hwnd)

win32gui.EnumWindows(callback, None)

return matches[0] if matches else None

def arrange_windows(graph_hwnd):

"""Place simulation left and graphs right."""

# Graphs behind the simulation.

if graph_hwnd:

win32gui.SetWindowPos(

graph_hwnd,

win32con.HWND_NOTOPMOST,

left_w, 0,

right_w, window_h,

win32con.SWP_NOACTIVATE |

win32con.SWP_SHOWWINDOW

)

sim_hwnd = find_mujoco_window()

if sim_hwnd:

win32gui.SetWindowPos(

sim_hwnd,

win32con.HWND_TOP,

0, 0,

left_w, window_h,

win32con.SWP_SHOWWINDOW

)

return True

return False

# ==========================================

# 4. MUJOCO MODEL

# ==========================================

xml = f"""

<option timestep="{DT}"

gravity="0 0 -{GRAVITY}"

wind="{WIND_VECTOR[0]} {WIND_VECTOR[1]} {WIND_VECTOR[2]}"

density="1.2"

viscosity="0"/>

<geom name="ground"

type="plane"

size="30 30 0.1"

rgba="{ground_color}"/>

<body name="ball"

pos="0 0 {DROP_HEIGHT}">

<geom name="ball_geom"

type="sphere"

size="{radius}"

mass="{mass}"

rgba="{ball_color}"/>

</body>

</worldbody>

<pair geom1="ground"

geom2="ball_geom"

condim="3"

friction="0.8 0.005 0.0001 0.0001 0.0001"

solref="-{stiffness} -{damping}"

solimp="0.95 0.99 0.001"/>

</contact>

</mujoco>

"""

model = mujoco.MjModel.from_xml_string(xml)

data = mujoco.MjData(model)

ball_id = model.body("ball").id

ball_geom_id = model.geom("ball_geom").id

ground_id = model.geom("ground").id

# ==========================================

# 5. PHYSICS DATA

# ==========================================

times = []

positions = []

velocities = []

energies = []

bounce_count = 0

rebound_heights = []

def physics():

pos = data.xipos[ball_id].copy()

# For this single free-joint body,

# translational qvel occupies [0:3].

vel = data.qvel[:3].copy()

momentum = mass * vel

ep = mass * GRAVITY * pos[2]

# Translational kinetic energy.

ek = 0.5 * mass * np.dot(vel, vel)

et = ep + ek

return pos, vel, momentum, ep, ek, et

def record():

pos, vel, p, ep, ek, et = physics()

times.append(data.time)

positions.append(pos)

velocities.append(vel)

energies.append([ep, ek, et])

# ==========================================

# 6. CREATE LIVE GRAPHS

# ==========================================

plt.ion()

fig, axes = plt.subplots(

3, 1,

figsize=(7, 9),

sharex=True

)

fig.canvas.manager.set_window_title(GRAPH_TITLE)

ax_e, ax_p, ax_v = axes

fig.suptitle(

f"{BALL_TYPE.upper()} / {GROUND_TYPE.upper()}\n"

f"Wind X={WIND_VECTOR[0]}, "

f"Y={WIND_VECTOR[1]} m/s"

)

# Energy lines

le1, = ax_e.plot([], [], label="Potential")

le2, = ax_e.plot([], [], label="Kinetic")

le3, = ax_e.plot([], [], label="Total")

ax_e.set_title("Energy")

ax_e.set_ylabel("Joules")

ax_e.legend(loc="upper right")

ax_e.grid(True)

# Position lines

lp1, = ax_p.plot([], [], label="X")

lp2, = ax_p.plot([], [], label="Y")

lp3, = ax_p.plot([], [], label="Z")

ax_p.set_title("Position")

ax_p.set_ylabel("Meters")

ax_p.legend(loc="upper right")

ax_p.grid(True)

# Velocity lines

lv1, = ax_v.plot([], [], label="Vx")

lv2, = ax_v.plot([], [], label="Vy")

lv3, = ax_v.plot([], [], label="Vz")

ax_v.set_title("Velocity")

ax_v.set_xlabel("Time (s)")

ax_v.set_ylabel("m/s")

ax_v.legend(loc="upper right")

ax_v.grid(True)

fig.tight_layout()

plt.show(block=False)

# Complete initial window creation.

fig.canvas.draw()

fig.canvas.flush_events()

graph_hwnd = win32gui.FindWindow(None, GRAPH_TITLE)

def update_graphs():

t = np.asarray(times)

p = np.asarray(positions)

v = np.asarray(velocities)

e = np.asarray(energies)

if len(t) == 0:

return

le1.set_data(t, e[:, 0])

le2.set_data(t, e[:, 1])

le3.set_data(t, e[:, 2])

lp1.set_data(t, p[:, 0])

lp2.set_data(t, p[:, 1])

lp3.set_data(t, p[:, 2])

lv1.set_data(t, v[:, 0])

lv2.set_data(t, v[:, 1])

lv3.set_data(t, v[:, 2])

for ax in axes:

ax.relim()

ax.autoscale_view()

ax.set_xlim(0, max(2, data.time + 0.2))

# Update without calling plt.pause(),

# which can change window focus.

fig.canvas.draw_idle()

fig.canvas.flush_events()

# ==========================================

# 7. DRAW WIND VECTOR IN 3D

# ==========================================

def draw_wind(viewer):

scene = viewer.user_scn

scene.ngeom = 0

if scene.maxgeom < 1:

return

if np.linalg.norm(WIND_VECTOR) < 1e-9:

return

start = np.array([-3.0, -2.0, 8.0])

end = start + WIND_VECTOR * 0.5

geom = scene.geoms[0]

mujoco.mjv_initGeom(

geom,

mujoco.mjtGeom.mjGEOM_ARROW,

np.zeros(3),

np.eye(3).flatten(),

np.array([0.1, 0.4, 1, 1],

dtype=np.float32)

)

mujoco.mjv_connector(

geom,

mujoco.mjtGeom.mjGEOM_ARROW,

0.08,

start,

end

)

scene.ngeom = 1

# ==========================================

# 8. COLLISION DETECTION

# ==========================================

def detect_collision():

for i in range(data.ncon):

c = data.contact[i]

if {c.geom1, c.geom2} != {

ground_id, ball_geom_id

continue

force = np.zeros(6)

mujoco.mj_contactForce(

model, data, i, force

)

if force[0] > 1e-8:

return i, force[0]

return None, 0.0

def collision_callback(index, force, old_vel):

c = data.contact[index]

print("\n========== COLLISION ==========")

print(f"Time: {data.time:.4f} s")

print(f"Ball: {BALL_TYPE}")

print(f"Ground: {GROUND_TYPE}")

print(f"Contact XYZ: {np.round(c.pos, 3)}")

print(f"Previous velocity: {np.round(old_vel, 3)}")

print(f"Normal force: {force:.2f} N")

print("================================\n")

# ==========================================

# 9. TERMINAL PHYSICS

# ==========================================

def print_status():

pos, vel, p, ep, ek, et = physics()

print(

f"t={data.time:6.3f} | "

f"XYZ={np.round(pos, 3)} | "

f"V={np.round(vel, 3)}"

)

print(

f"Momentum={np.round(p, 3)} | "

f"Epot={ep:7.2f} J | "

f"Ekin={ek:7.2f} J | "

f"Etotal={et:7.2f} J"

)

# ==========================================

# 10. MAIN SIMULATION

# ==========================================

def main():

global bounce_count

print("\nMUJOCO LIVE PHYSICS")

print("Ball:", BALL_TYPE)

print("Mass:", mass, "kg")

print("Diameter:", radius * 2, "m")

print("Ground:", GROUND_TYPE)

print("Wind:", WIND_VECTOR, "m/s")

print("Timestep:", DT, "s\n")

record()

print_status()

graph_steps = max(1, round(GRAPH_INTERVAL / DT))

view_steps = max(1, round(VIEW_INTERVAL / DT))

print_steps = max(1, round(PRINT_INTERVAL / DT))

step = 0

was_touching = False

tracking_rebound = False

with mujoco.viewer.launch_passive(

model,

data,

show_left_ui=False,

show_right_ui=False

) as viewer:

with viewer.lock():

viewer.cam.lookat[:] = [0, 0, 5]

viewer.cam.distance = 23

viewer.cam.azimuth = 135

viewer.cam.elevation = -15

viewer.sync()

# Position MuJoCo left,

# graphs right and behind.

arrange_windows(graph_hwnd)

wall_start = time.perf_counter()

print("Program started...")

# This line adds the 3-second delay

time.sleep(3)

# Set camera.

while (

viewer.is_running()

and data.time < SIM_TIME

if not plt.fignum_exists(fig.number):

break

old_vel = data.qvel[:3].copy()

old_vz = data.qvel[2]

# Physics step: 1 ms

mujoco.mj_step(model, data)

step += 1

record()

# Contact check

ci, force = detect_collision()

touching = ci is not None

if touching and not was_touching:

bounce_count += 1

print(

f"\nBOUNCE CONTACT {bounce_count}"

)

collision_callback(

ci, force, old_vel

)

if was_touching and not touching:

tracking_rebound = True

# Detect highest rebound point

vz = data.qvel[2]

if (

tracking_rebound

and not touching

and old_vz > 0

and vz <= 0

height = data.xipos[ball_id, 2]

rebound_heights.append(height)

print(

f"REBOUND HEIGHT: {height:.3f} m"

)

tracking_rebound = False

was_touching = touching

# Update MuJoCo viewer.

if step % view_steps == 0:

with viewer.lock():

draw_wind(viewer)

viewer.sync()

# Update graphs behind viewer.

if step % graph_steps == 0:

update_graphs()

# Terminal output.

if step % print_steps == 0:

print_status()

# Approximate real-time speed.

target = wall_start + data.time

remaining = target - time.perf_counter()

if remaining > 0:

time.sleep(remaining)

# =====================================

# 11. RESULTS

# =====================================

print("\nSIMULATION COMPLETE")

print("Collision events:", bounce_count)

for i, h in enumerate(rebound_heights, 1):

print(f"Rebound {i}: {h:.3f} m")

if plt.fignum_exists(fig.number):

update_graphs()

plt.ioff()

plt.show()

if __name__ == "__main__":

main()

admin

Administrator

Visit Website View All Posts

Related Stories

קורס רובוטיקה ובינה מלאכותית 04-RB302 מבוא MuJoCo

רובוטיקה ובינה מלאכותית : AI-106

קורס רובוטיקה ובינה מלאכותית Inverse Kinematics (IK) – : 01-RB302

You may have missed

קורס רובוטיקה ובינה מלאכותית 04-RB302 מבוא MuJoCo

קורס רובוטיקה ובינה מלאכותית 03-RB302 מבוא MuJoCo

רובוטיקה ובינה מלאכותית : AI-106

קורס רובוטיקה ובינה מלאכותית Inverse Kinematics (IK) – : 01-RB302

MuJoCo – Advanced physics simulation

1. מה אפשר לעשות עם MuJoCo?

2. דוגמאות לפרויקטים אמיתיים

3. מי משתמש ב־MuJoCo בעולם הרובוטיקה?

4. אילו מערכות תומכות ב־MuJoCo?

האם MuJoCo מתאים לפיתוח הרובוטים שלך?

חלק א : תרגול מנוע פיזיקאלי – MuJoCo

דוגמה: כדורסל במסה 0.62 ק״ג בגובה 10 מטר

התוכנה מדמה נפילה וקפיצה של כדורסל מגובה 10 מטרים, באמצעות מנוע הפיזיקה MuJoCo.

מה התוכנה עושה?

נריץ את הקוד

1. פרמטרים של הסביבה והפיזיקה

2. פרמטרים של הכדור

סוגי כדורים שכבר מוגדרים בתוכנה

3. פרמטרים של הקרקע וההתנגשות

ערכי המשטחים המוגדרים בקוד

4. פרמטרים של התצוגה והגרפים

5. פרמטרים נוספים שכדאי להוסיף לתוכנה

About the Author

Related Stories

You may have missed