A Constraint Embedding Approach for Dynamics Modeling of Parallel Kinematic Manipulators with Hybrid Limbs

In plain words

Some robots hold their tool with several arms at once, and each arm contains a small closed loop of rods. Writing the motion equations for such a robot is hard, because every loop adds constraints that must hold at every moment.

The idea here is to deal with each loop on its own. The loop's constraints are solved numerically, which leaves the arm as an ordinary chain of joints described by a few free settings. Finding the joint settings that reach a given tool position is then an iteration that re-checks the loops at every step. The arm equations are assembled into one model for the whole robot, which is what a controller needs to compute the motor torques. The method is shown on a two-degree-of-freedom example.

TL;DR

• The paper gives a dynamics model for parallel manipulators whose limbs contain closed kinematic loops in series ("hybrid" limbs), without simplifying those loops §1, §2.
• Each limb's loop constraints are solved locally and numerically, which turns the limb into a serial chain in independent coordinates §3.3, §3.4.
• Limb inverse kinematics uses a nested Newton-Raphson scheme alg. 1, alg. 2, or one combined iteration alg. 3 when the loop constraints are well conditioned §4.2.
• The limb equations of motion are combined into a task-space model that yields actuator torques for feedforward control eq. 39, eq. 45.
• Results are author-reported and limited to iteration counts and plotted torques for one 2-DOF example; no error figures are given §6.4.

Problem

• Standard multibody formulations impose the constraints of the whole robot at once. For many lower-mobility parallel robots this gives a redundant constraint set, which makes the model large and numerically awkward §1, §4.3.
• A common shortcut replaces a loop by an equivalent joint, for example a 1-DOF Π-joint for a parallelogram. This is kinematically equivalent but hides internal singularities and drops the dynamics of the loop's members, so non-symmetric mass distributions and joint reactions cannot be represented §1.
• The loop constraints generally cannot be solved in closed form, so a general method has to solve them numerically §1, §3.4.
• Model-based control needs accurate dynamics, including the feedforward torques that the inverse dynamics produces §1, §5.4.

Method

The paper's steps, in order. Equation numbers follow the compiled paper's count; section numbers are given where an equation is not numbered.

1. Topology. Bodies are vertices and joints are edges of a graph Γ. Each limb is a subgraph with independent cycles, the fundamental cycles (FC). Within a limb the FCs are edge-disjoint, which the paper calls a hybrid limb §2. One cut-joint is removed per FC, giving a spanning tree. The tree is directed toward ground, and bodies are numbered so that a predecessor always has a smaller index §2.

2. Tree kinematics. The pose of body k is a product of exponentials of the joint screws along its path to ground, times a reference configuration §3.1, eq. 1, eq. 2. A body-frame variant with reference transforms between joints is equivalent eq. 3. The platform pose is the same kind of product, multiplied by the platform reference, which is shared by all limbs eq. 4.

3. Jacobian. The body twist is the geometric Jacobian times the joint rates eq. 5. The system Jacobian factors as a block-triangular matrix built from adjoint maps times a block-diagonal matrix of joint screws eq. 6, eq. 7, eq. 8. Its time derivative has a closed form eq. 9, and the system acceleration follows from it eq. 10.

4. Task space. The platform twist is a fixed linear map of the task-space velocity V_t, with a unimodular 6×δ_p selection matrix P_p §3.2, eq. 11.

5. Loop constraints. The cut-joint of each FC gives m geometric constraints g = 0, their velocity form G θ̇ = 0 and their acceleration form eq. 12, eq. 13, eq. 14. The joint variables of the FC are split into dependent variables y, whose Jacobian block G_y is square and invertible, and independent variables q, whose block is G_q §3.4, eq. 16. The rates and accelerations of the FC then follow from a matrix H with θ̇ = H q̇ and θ̈ = H q̈ + Ḣ q̇ eq. 17. The paper gives H = [−G_y⁻¹ G_q; I] eq. 18 and its derivative eq. 19. Stacking all FCs gives the limb-level H eq. 20.

6. Local solution. The geometric solution of each FC is written as θ = ψ(q), obtained numerically §3.4, eq. 15. Each FC is solved independently of the others, which is the local constraint embedding.

7. Limb forward and inverse kinematics. The platform pose is φ = ψ_p ∘ ψ eq. 21. The forward-kinematics Jacobian L_p = J_p H eq. 22 has rank δ_p(l), the platform DOF of the separated limb. The inverse map f_(l) is local, because the map is surjective but not injective §3.5, §3.6, eq. 23. Taking a square task-space Jacobian L_t gives F = L_t⁻¹ D_t, where D_t assigns the PKM task components to the limb rows §3.6, eq. 24 to eq. 27. The limb velocities are θ̇ = H F V_t eq. 28, and the accelerations follow eq. 29. The paper assumes non-redundant limbs for inverse kinematics, that is δ_p(l) = δ_l §3.6.

8. PKM inverse kinematics. The actuator velocities are J_IK V_t, where J_IK collects the actuator rows of the limbs' F matrices §3.7, eq. 30.

9. Numerical limb inverse kinematics. For a target pose the independent increment is Δq = F_t Δx_t eq. 31, with Δx_t = P_t (I − ΔC_p)^∨ and ΔC_p = C̄_p⁻¹ C_p, where C̄_p is the pose evaluated at the current configuration §4.1.1. For the IRSBot the selection matrix P_t is given explicitly eq. 32. The increment is applied, the loops are re-solved, and the process repeats until the task error is small. This is Algorithm 1 with Algorithm 2 as its inner solver alg. 1, alg. 2. The norm on SE(3) is a left-invariant norm, ‖X‖ = α‖ξ‖ + β‖η‖, with weights α and β that are not stated §4.1.1.

10. Loop solver. Algorithm 2 first moves the independent variables by Δq and takes one linearised step for the dependent variables. It then applies Newton corrections, Δy = −G_y⁻¹ g, until the loop residual is below ε alg. 2, §4.1.2. The linear system behind this step is given as eq. 33.

11. Compound variant. Algorithm 3 performs one loop-solver step per outer iteration: Δθ = H F_t P_t (I − ΔC_p)^∨ alg. 3, §4.2. The loop residual then only enters the stopping test. The paper justifies this only for regular loop constraints §6.4.1.

12. Limb equations of motion. The tree-topology EOM of a limb without its platform joint are written in the standard form eq. 34, with joint rates related to the independent rates by H̄ eq. 35. Projecting with H̄ gives the limb equations in the independent coordinates q̄ eq. 36, eq. 37.

13. Platform. The platform is a floating body with Newton-Euler equations, a constant mass matrix in the platform frame and a gyroscopic term G_p = −ad^T_{V_p} eq. 38.

14. Task-space dynamics. Using the variations δθ̇ = H̄ F̄ δV_t, the limb and platform terms give one task-space equation eq. 39. Its mass matrix M_t and Coriolis matrix C_t eq. 40, eq. 41 are sums over the limbs plus the platform. The generalized forces are the end-effector wrench eq. 42, gravity eq. 43 and the remaining forces eq. 44.

15. Feedforward control. The actuator forces that produce the desired task motion follow from u = J_IK^(−T) (M_t V̇_t + C_t V_t + W_t^grav + W_t − W_t^EE) eq. 45. This needs J_IK to be square and invertible.

16. Cut-joint constraints. Appendix A lists the position and orientation constraints of each cut-joint, built from elementary relative-displacement constraints. A joint with δ DOF gives 6 − δ constraints: revolute 5, spherical 3, universal 4 app. A, app. A.1, app. A.2.

Pseudocode

Inner loop solver for one FC, with the paper's Newton correction alg. 2:

# Loop constraint solver for one fundamental cycle  [alg. 2]
# Input:  theta (dependent y, independent q), delta_q, tolerance eps
# Output: theta that satisfies the loop constraints

def solve_loop_constraints(theta, delta_q, eps):
    # Move the independent coordinates by delta_q  [alg. 2]
    independent = independent_part(theta) + delta_q
    # Initial step: linearised update of the dependent coordinates  [alg. 2]
    # The Jacobians are taken at the input configuration  [alg. 2]
    delta_y = -solve(G_y(theta), G_q(theta) @ delta_q)
    theta = join(dependent_part(theta) + delta_y, independent)
    # Correction steps: Newton on the loop residual  [alg. 2]
    while norm(g(theta)) > eps:
        # Jacobian is re-evaluated at the current configuration  [alg. 2]
        delta_y = -solve(G_y(theta), g(theta))
        theta = join(dependent_part(theta) + delta_y, independent)
    return theta

Outer loop, inverse kinematics of one limb alg. 1:

# Inverse kinematics of one limb with loop constraints  [alg. 1]
# Input:  theta_0 (admissible), target platform pose C_p, eps
# Output: theta of the limb at the target pose

def limb_inverse_kinematics(theta_0, target_pose, eps):
    # Start from the admissible initial configuration  [alg. 1]
    theta = theta_0
    # Task-space error from the pose mismatch  [alg. 1, eq. 4]
    task_error = pose_task_error(theta, target_pose)
    while norm(task_error) > eps:
        # Independent increment from the task error  [eq. 31]
        # F_t is evaluated at the current theta  [eq. 31]
        delta_q = F_t(theta) @ task_error
        # Re-solve the loops for the new independent coordinates  [alg. 2]
        theta = solve_loop_constraints(theta, delta_q, eps)
        # Recompute the task error at the new configuration  [alg. 1]
        task_error = pose_task_error(theta, target_pose)
    return theta

Compound scheme, one loop step per outer step alg. 3:

# Combined inverse kinematics and loop constraints  [alg. 3]
# Input:  theta_0, target pose C_p, tolerances eps_1 and eps_2
# Output: theta of the limb at the target pose

def compound_inverse_kinematics(theta_0, target_pose, eps_1, eps_2):
    # Start from the admissible initial configuration  [alg. 3]
    theta = theta_0
    task_error = pose_task_error(theta, target_pose)
    # Stop when both the task error and the loop residual are small  [alg. 3]
    while norm(task_error) > eps_1 or norm(g(theta)) > eps_2:
        # One linearised step on all joint variables  [alg. 3, eq. 20]
        delta_theta = H(theta) @ F_t(theta) @ task_error
        theta = theta + delta_theta
        # Recompute the task error  [alg. 3]
        task_error = pose_task_error(theta, target_pose)
    return theta

pose_task_error(theta, target) is a helper, not a named step in the paper. It evaluates ψ_p(θ) eq. 4, forms ΔC_p = C̄_p⁻¹ C_p, and returns P_t (I − ΔC_p)^∨ alg. 1.

Hyperparameters

Values for the IRSBot-2 example, where the paper gives them.

Results

Author-reported. Setup: one limb of the IRSBot-2 (two loops, 2-DOF platform), trajectory from the hyperparameter table, MATLAB implementation of the closed-form equations, validated against the commercial MBS tool Alaska §6.4. No timings, hardware, or error norms are reported.

Paper vs code

No official code.

Search done: the paper text (no code link), the stored arXiv metadata (no comment or link field), and no project page. Then GitHub repository searches for "constraint embedding" (none of the first 19 results is by the authors), "IRSBot-2 Mueller" (none), and "hybrid limbs parallel kinematic" (none). The four repositories found for "IRSBot" are not attributable to the authors, so none was used. The paper mentions a MATLAB implementation and the Alaska validation, but no release.

Pitfalls

• Redundant loop constraints are claimed but not specified. The conclusion says redundant constraints in a loop can be handled inside Algorithm 2 §7. The derivation assumes each FC's m constraints are independent §3.3, and Algorithm 2 inverts a square G_y alg. 2. The paper gives no rule for choosing independent rows, and no redundant example is computed. The 4U loop of the 3R[2UU] Delta is cited as the motivating case §3.4 remark, §7. Do not implement the redundant case from this paper.
• Algorithm 3 has no constraint correction. The loop residual is only in the stopping test. It converges only because the loops are regular in this example §6.4.1.
• Choice of independent coordinates. The choice of q for each FC sets the conditioning of G_y and of H, and the paper says it is not unique §3.4 remark. For the IRSBot the proximal loop uses φ_1 and the distal loop uses the two U-joint 6 angles §6.2.
• Proximal loop is solved by hand. The planar 4-bar loop is handled in closed form, with the relation φ_1 = φ_3 = −φ_2, not by the numerical solver §6.2. Only the distal loop uses Algorithms 1 and 2 §6.4.1.
• Near singularities. The numerical scheme needs G_y or G_q to be well conditioned, and the paper says this fails near singularities §4.1.2. At the input singularity the Jacobian condition grows and the accelerations spike, but the iteration counts stay small §6.4.3.
• Initial configuration. The solution is only valid near the starting configuration §4.1.2. The paper says that switching coordinates or constraint parameterisations may be needed between motion modes, and that kinematotropic robots change their DOF, but it gives no switching procedure §3.4 remark.
• Norm weights unstated. The left-invariant norm uses α and β, which are not given. Both the outer and inner stopping tests depend on them, and the threshold ε mixes metres and radians.
• Notation drift in Algorithm 1. The paper writes F without its argument in Algorithm 1 but F_t(θ) in eq. 31. Evaluate F_t at the current configuration on every iteration, as Algorithm 3 does alg. 1, alg. 3.
• Non-redundant limbs only. The inverse kinematics assumes δ_p(l) = δ_l §3.6. The task-space inverse dynamics needs J_IK to be square eq. 45. Both assumptions hold for the example but are not covered in general.
• Velocity-level integration drifts. Integrating only the velocity constraints lets the position error grow. The paper prefers the position-level Newton solution for feedforward torques §4.1.2 remark.
• Dimensions conflict between sections. §6.1 gives L_1 = 1/4 m and L_2 = 1/2 m. §6.4.2 says body 1 has length L_1 = 1/2 m and that links 4 and 5 have length L_2 = 3/4 m. The stated masses match §6.1: with aluminium at 2700 kg/m³, a 1/4 m bar of side 1/24 m gives 1.1719 kg, and a 1/2 m rod of radius 1/60 m gives 1.1781 kg. This is a reviewer's check, not a statement in the paper.
• m_3 is not reproducible from the stated geometry. Body 3 is described as a beam of length L_1 with side L_1/10. At 2700 kg/m³ that gives about 0.42 kg with L_1 = 1/4 m, or 3.4 kg with L_1 = 1/2 m, not 21.1875 kg. The paper does not explain the value. This is a reviewer's check.
• Time variable undefined. The trajectory uses s(t) = sin²(νπt/T) with ν = 3 cycles per second, but T is never defined.
• Gravity and density unstated. Neither the gravity magnitude nor the density is given in the text. The masses above imply 2700 kg/m³ for aluminium.
• Time step. The paper uses 1 ms for inverse kinematics and 10 ms for inverse dynamics. At 10 ms the outer loop needs three iterations almost every step fig. 11.

Lineage

• Builds on: the author's earlier systematic task-space formulation for parallel manipulators with complex limbs, cited as MMT2022. The paper takes its task-space equations from that work §1, §5.3.
• Compared against: standard relative- and absolute-coordinate multibody formulations with cut-joint constraints, where the overall constraint set is redundant for overconstrained robots §4.3. Also the Π-joint simplification §1.
• Related: 2412.13681, the same author's modular dynamics paper for the same class of robots, published the same day. The cross-references between the two are not checked here.
• Superseded by: not stated.
• Future work: applying the modular concept of the cited earlier papers to the constraint embedding §7.