Principle:ARISE Initiative Robosuite Whole Body IK Control
| Knowledge Sources | |
|---|---|
| Domains | Robotics, Inverse_Kinematics |
| Last Updated | 2026-02-15 07:00 GMT |
Overview
A whole-body inverse kinematics controller that solves for joint configurations satisfying multiple prioritized task-space objectives simultaneously using quadratic programming.
Description
Traditional inverse kinematics (IK) solvers compute joint angles for a single kinematic chain (e.g., one robot arm) to achieve a desired end-effector pose. However, modern robotic platforms -- such as humanoids, mobile manipulators, and bimanual systems -- have many more degrees of freedom distributed across multiple kinematic chains. Whole-body IK treats the entire robot as a single kinematic system and solves for joint configurations that simultaneously satisfy multiple task-space objectives, such as reaching targets with both hands while maintaining balance and a preferred posture.
The approach formulates IK as an optimization problem over joint velocities. Each objective (end-effector pose, posture, center-of-mass position) is expressed as a task with an associated cost weight and error function. The solver computes the joint velocity vector that minimizes a weighted sum of task errors, subject to joint limits and other constraints. This is solved as a quadratic program (QP) at each control step, producing a velocity command that is then integrated to update the joint configuration.
A task-priority framework ensures that high-priority tasks (e.g., end-effector tracking) are satisfied preferentially over low-priority tasks (e.g., posture maintenance). Each task defines a Jacobian mapping from joint velocities to task-space velocities. The solver combines these Jacobians with their respective cost weights to form the QP objective, and Levenberg-Marquardt damping is applied to handle kinematic singularities gracefully.
The controller supports multiple input modes: absolute target poses, delta (incremental) poses in world or robot-base reference frames, and coupled delta poses that apply position and orientation changes as a single rigid-body transformation. Posture tasks can be weighted per-joint, allowing certain joints (e.g., torso or leg joints of a humanoid) to be preferentially held near their default configuration while arm joints are free to track end-effector targets.
Usage
Use whole-body IK control for robots with redundant degrees of freedom that must coordinate multiple body parts toward simultaneous objectives. This is particularly appropriate for humanoid robots, dual-arm manipulators, and mobile manipulators where the base, torso, and arms must all contribute to reaching task-space goals. The controller is configured through JSON files that specify which joints participate in the IK solve, the reference sites for end-effector tracking, posture weights, and solver parameters.
Theoretical Basis
Task formulation:
Each task i defines an error function e_i(q) and a Jacobian J_i(q):
e_i(q) = x_target_i - x_current_i(q) (task-space error)
J_i(q) = d(x_i) / d(q) (task Jacobian)
Quadratic program formulation:
The joint velocity dq is found by solving:
minimize sum_i w_i * || J_i * dq - alpha_i * e_i ||^2
+ lambda * || dq ||^2
subject to dq_min <= dq <= dq_max
where w_i is the task cost, alpha_i is the task gain (for low-pass filtering), and lambda is the Levenberg-Marquardt damping term that regularizes the solution near singularities.
Weighted posture task:
A posture task penalizes deviation from a reference configuration q_ref:
e_posture = W * (q_ref - q)
J_posture = W * I
where W is a diagonal weight matrix. Higher weights on specific joints cause them to track the reference posture more strongly, while low weights allow those joints to be used freely by higher-priority tasks.
Configuration integration:
After solving the QP, the joint configuration is updated:
q_new = q + dq * dt
where dt = 1 / solve_freq. Forward kinematics is then recomputed on the updated configuration.
Reference frame handling:
Input actions in the robot base frame are transformed to the world frame before setting targets:
X_world = X_base_to_world * X_input (for absolute targets)
dp_world = R_base_to_world * dp_input (for delta positions)