| """Inverse kinematics for the SO-101 with the gripper pointing straight down. |
| |
| The arm has five joints before the gripper: pan, lift, elbow, wrist flex, wrist roll. |
| With the gripper vertical, those five set the pinch point's position (3) and the |
| jaws' yaw on the table (1), and one more constraint (vertical) is met by wrist flex. |
| So any reachable (point, yaw) pair has an exact solution. |
| |
| A tilt can be added for far reaches: the fingertips lean outward, away from the |
| base, within the arm's own vertical plane (rotation about the shoulder-lift axis), |
| which the five joints can still reach exactly. Near the edge of reach 10 degrees |
| of tilt about doubles the height the pinch point can be lifted to. A negative tilt |
| leans the fingertips inward, toward the base, which moves the hand's top (wrist and |
| wrist camera) away from the shoulder when working close to the arm. |
| |
| Frames: the `gripper` body's -z axis runs from the wrist toward the fingertips and |
| its +x axis is the closing direction, from the fixed jaw toward the moving jaw. |
| """ |
| from __future__ import annotations |
|
|
| import mujoco |
| import numpy as np |
|
|
| ARM_JOINTS = ("shoulder_pan", "shoulder_lift", "elbow_flex", "wrist_flex", "wrist_roll") |
| GRIPPER_JOINT = "gripper" |
|
|
|
|
| def yaw_rotation(yaw: float) -> np.ndarray: |
| """Gripper-body orientation in the world: pointing down, closing along `yaw`.""" |
| c, s = np.cos(yaw), np.sin(yaw) |
| x = np.array([c, s, 0.0]) |
| z = np.array([0.0, 0.0, 1.0]) |
| return np.column_stack([x, np.cross(z, x), z]) |
|
|
|
|
| class Kinematics: |
| def __init__(self, model: mujoco.MjModel): |
| self.m = model |
| self.d = mujoco.MjData(model) |
| self.qadr = np.array([model.jnt_qposadr[model.joint(j).id] for j in ARM_JOINTS]) |
| self.vadr = np.array([model.jnt_dofadr[model.joint(j).id] for j in ARM_JOINTS]) |
| self.lo = model.jnt_range[[model.joint(j).id for j in ARM_JOINTS], 0] |
| self.hi = model.jnt_range[[model.joint(j).id for j in ARM_JOINTS], 1] |
| self.body = model.body("gripper").id |
| self.lift_joint = model.joint("shoulder_lift").id |
| self._jp = np.zeros((3, model.nv)) |
| self._jr = np.zeros((3, model.nv)) |
|
|
| def _set(self, q): |
| self.d.qpos[self.qadr] = q |
| mujoco.mj_kinematics(self.m, self.d) |
| mujoco.mj_comPos(self.m, self.d) |
|
|
| def pose(self, q, offset=np.zeros(3)): |
| """World position of a gripper-frame point, and the gripper rotation.""" |
| self._set(q) |
| R = self.d.xmat[self.body].reshape(3, 3).copy() |
| return self.d.xpos[self.body] + R @ offset, R |
|
|
| def target_rotation(self, target, yaw, tilt): |
| """Gripper orientation for jaw `yaw`, fingertips tilted outward by `tilt` rad |
| (inward, toward the base, if `tilt` is negative). |
| |
| Uses the shoulder-lift axis of the configuration last set (its pan).""" |
| Rt = yaw_rotation(yaw) |
| if tilt == 0.0: |
| return Rt |
| outward = tilt > 0 |
| tilt = abs(tilt) |
| a = self.d.xaxis[self.lift_joint].copy() |
| a[2] = 0.0 |
| a /= np.linalg.norm(a) |
| out = np.asarray(target[:2]) - self.d.xanchor[self.lift_joint][:2] |
| K = np.array([[0, -a[2], a[1]], [a[2], 0, -a[0]], [-a[1], a[0], 0]]) |
| for sign in (1.0, -1.0): |
| Rtilt = np.eye(3) + np.sin(sign * tilt) * K + (1 - np.cos(sign * tilt)) * K @ K |
| fingers = -Rtilt[:, 2] |
| if (fingers[:2] @ out > 0) == outward: |
| return Rtilt @ Rt |
| return Rt |
|
|
| def solve(self, target, yaw, offset, q0, iters=200, tol=2e-5, tilt=0.0): |
| """Joint angles putting `offset` (gripper frame) at `target`, gripper down at `yaw` |
| and leaning outward by `tilt`. |
| |
| Returns (q, position error m, orientation error rad). |
| """ |
| q = np.clip(np.asarray(q0, float).copy(), self.lo, self.hi) |
| for _ in range(iters): |
| p, R = self.pose(q, offset) |
| Rt = self.target_rotation(target, yaw, tilt) |
| e_pos = target - p |
| e_rot = 0.5 * sum(np.cross(R[:, i], Rt[:, i]) for i in range(3)) |
| if np.linalg.norm(e_pos) < tol and np.linalg.norm(e_rot) < tol * 20: |
| break |
| mujoco.mj_jac(self.m, self.d, self._jp, self._jr, p, self.body) |
| J = np.vstack([self._jp[:, self.vadr], 0.05 * self._jr[:, self.vadr]]) |
| e = np.concatenate([e_pos, 0.05 * e_rot]) |
| dq = J.T @ np.linalg.solve(J @ J.T + 1e-8 * np.eye(6), e) |
| step = np.max(np.abs(dq)) |
| if step > 0.2: |
| dq *= 0.2 / step |
| q = np.clip(q + dq, self.lo, self.hi) |
| p, R = self.pose(q, offset) |
| Rt = self.target_rotation(target, yaw, tilt) |
| e_rot = 0.5 * sum(np.cross(R[:, i], Rt[:, i]) for i in range(3)) |
| return q, float(np.linalg.norm(target - p)), float(np.linalg.norm(e_rot)) |
|
|
| def solve_global(self, target, yaw, offset, q0=None, tilt=0.0): |
| """Multi-start solve for waypoints far from any known configuration.""" |
| pan = np.arctan2(target[1], target[0]) |
| starts = [] if q0 is None else [np.asarray(q0, float)] |
| for lift, elbow, flex in ((0.0, 0.0, 1.5), (0.5, -0.2, 1.3), (-0.6, 0.9, 1.3), (-1.0, 1.3, 1.4)): |
| for roll in np.linspace(-2.4, 2.4, 7): |
| starts.append(np.array([pan, lift, elbow, flex, roll])) |
| best = None |
| for s in starts: |
| q, ep, er = self.solve(target, yaw, offset, s, iters=150, tilt=tilt) |
| score = ep + 0.02 * er |
| if best is None or score < best[3]: |
| best = (q, ep, er, score) |
| if ep < 1e-4 and er < 2e-3: |
| break |
| return best[:3] |
|
|
