Closed Loop Inverse Kinematics

Definition

Closed-loop inverse kinematics (CLIK) solves the differential inverse-kinematics problem
by integrating joint velocities while feeding back the task-space pose error between the
desired and the forward-kinematics-computed end-effector trajectory, so that discrete-time
numerical drift is suppressed rather than accumulated (caccavale2001kinematic).
It is the inverse-kinematics layer of kinematic control: the manipulator kinematics is
resolved outside the motion loop, separating singularity/redundancy handling from the
joint-space tracking controller. Caccavale & Siciliano pose it for a free-floating
space manipulator (uncontrolled, reactive base), so the resolving map is the generalized
Jacobian, which folds in the base reaction — this regime assumption matters for our
free-flying (fully-actuated base) system, where the resolving Jacobian is a different object.

Key Equations

Symbols per notation.md.

Quaternion-based CLIK at the velocity level (eq. 19), using the geometric/generalized
Jacobian so no representation singularity arises:

with the EE position error, the
vector part of the orientation-error quaternion (the registry’s ),
and the desired EE twist feedforward. Note:
is the CLIK feedback gain; this symbol is not in notation.md (distinct from the
outer-loop stiffness and from ) — flagged for central addition.

Substituting into the differential kinematics gives the closed-loop error dynamics
— the defining CLIK property. The position error is governed by a homogeneous,
exponentially stable linear equation (eq. 16):

The quaternion orientation error (eq. 20) is non-homogeneous: it contains the
end-effector angular-velocity error
rather than the time derivative of , so its convergence is established by a
Lyapunov argument rather than read off as a linear-ODE eigenvalue:

Redundancy resolution with task priority (eq. 21): the higher-priority EE task uses the
pseudoinverse and the constraint task (e.g. spacecraft attitude)
is projected onto its null space:

Source Support

  • caccavale2001kinematic — primary: derives the Euler-angle and unit-quaternion CLIK algorithms for a redundant free-floating space manipulator, proves exponential convergence of the position error (and the Euler-angle error away from representation singularities) while establishing the quaternion-error convergence by a Lyapunov argument, and adds Jacobian-transpose and null-space (task-priority) redundancy variants.
  • resolved_motion_rate_control — CLIK is RMRC plus a pose-error feedback correction term; without the feedback it reduces to open-loop resolved-rate control, which drifts under discrete-time integration.
  • task_space_error_dynamics — the closed-loop error equations (16, 20) are the task-space error dynamics CLIK is designed to drive to zero: the position error (16) decays exponentially, while the quaternion-orientation error (20) is shown convergent by a Lyapunov argument.
  • pseudoinverse_jacobian — the Jacobian inverse/pseudoinverse is the resolving map that converts the feedback-corrected task velocity into joint rates.
  • kinematic_redundancy_resolution — the null-space projector in eq. (21) carries a secondary (constraint) task without disturbing the prioritized EE task.
  • damped_least_squares — CLIK still inverts , so near a kinematic_singularity the plain inverse blows up; damped least-squares replaces it to bound joint rates.

Open Questions

  • The source assumes a free-floating base (resolving via the generalized Jacobian ). For our free-flying fully-actuated base the resolving Jacobian is the circumcentroidal , not — does the exponential-stability argument for eqs. (16)/(20) carry over unchanged, or does base actuation change the error coupling?
  • Eqs. (16)/(20) are pure kinematic error dynamics that ignore base/arm dynamic_coupling; when CLIK only feeds a joint-space tracking controller, does the realized closed loop preserve exponential convergence under the coupled inertia ?
  • The task-priority variant (eq. 21) assumes non-singular for the pseudoinverse term; how should the singularity-robust path (damped/hold-last) interact with the null-space constraint task near a singularity?