Multibody dynamics of closed-loop mechanisms

Overview

A multibody model writes the motion equations of linked rigid bodies. A serial robot is a tree, so its equations are direct. A parallel manipulator holds its tool with several limbs, and some limbs contain closed loops of rods. Each loop adds constraints that must hold at every moment 2412.13638 §1. The problem is how to write these equations without simplifying the loops.

Both cards share one plan. Remove one cut-joint per loop, which leaves a spanning tree. Solve the loop constraints locally, so the limb acts as a serial chain in its independent coordinates. Then sum the limb terms into one task-space equation of motion 2412.13681 §3.1–3.3 [arxiv:2412.13638 §2, §3.4, eq. 39]. The two cards differ in how the loop constraints are handled. One linearises them into a rate map 2412.13681 §3.3.2. The other solves them numerically at each position, with a Newton correction 2412.13638 alg. 2.

Both cards are by the same author, were posted on the same day, and are draft compilations. Each reports one robot example. Neither reports error norms.

Variants

Screw and Lie-group model with a linearised loop map

Bodies are described by product-of-exponentials poses along the tree, and the joint rates of a limb are a linear map of its independent rates. For a loop, the dependent rates follow from the independent ones through a block split of the loop Jacobian, and the result is stacked into one matrix H 2412.13681 §3.3.2. The limb terms are then projected with the task-space Jacobian, and the platform follows the Newton-Euler equations 2412.13681 §6.4–6.5. A limb that is structurally identical to another is modelled once, in construction frames, and reused at each mount position 2412.13681 §7. Each limb's contribution to the inverse dynamics depends only on that limb's coordinates, so the limb terms can run on separate nodes 2412.13681 §8.2. The worked example is a Delta-type robot with three limbs, and it reports 2.74 µs for inverse kinematics plus inverse dynamics on one node 2412.13681 tab. 1. Card: Modular screw-theory model for parallel robots with complex limbs.

Numerical loop solver with Newton correction (constraint embedding)

Each loop's constraints are solved numerically inside its limb, and the limb then serves as a serial chain in the remaining variables [arxiv:2412.13638 §3.4]. The loop solver first moves the independent variables by a given increment and takes one linearised step for the dependent ones. It then applies Newton corrections until the loop residual is below a tolerance 2412.13638 alg. 2. Limb inverse kinematics is an outer iteration on the task error, which calls the loop solver at each step 2412.13638 alg. 1. A compound variant performs one loop step per outer iteration. The card reports about the same total cost as the nested form, and justifies the compound variant only for regular loop constraints 2412.13638 alg. 3, §6.4.1. The limb equations are projected with the same kind of H matrix, and a task-space model with actuator torques follows 2412.13638 eq. 36–45. The worked example is a two-degree-of-freedom IRSBot-2 limb. Its outer loop takes 1 to 3 iterations per step at a 1 ms time step, and 3 almost always at 10 ms 2412.13638 §6.4.1 fig. 11. Card: Numerical constraint-embedding model for hybrid-limb robots.

Replacing a loop by an equivalent joint (not recommended)

A common shortcut replaces a loop with an equivalent joint, for example a one-degree-of-freedom Π-joint for a parallelogram. The numerical card says 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 2412.13638 §1. It is listed here as the approach to avoid.

When to use which

Implementation sketch

Language-agnostic core of one limb and the task-space model. The loop solver is the variant-specific part: use the Newton loop from the numerical card, or the linear H map from the screw card.

# Common core of one closed-loop limb  [arxiv:2412.13681 §3.1–3.3]
# Shapes: n joints, delta independent coordinates per limb.

def limb_task_model(limb, theta, theta_dot):
    # Remove one cut-joint per fundamental cycle; the rest is a tree
    # [arxiv:2412.13638 §2]
    tree = spanning_tree(limb)
    # Loop constraints g(theta) = 0, one set per cut-joint
    # [arxiv:2412.13638 eq. 12]
    g = loop_constraints(limb, theta)
    # Split the loop Jacobian into dependent (square G_y) and independent G_q
    # [arxiv:2412.13638 eq. 16]
    G_y, G_q = split_jacobian(loop_jacobian(limb, theta))
    # Joint rates from independent rates: theta_dot = H q_dot
    # [arxiv:2412.13638 eq. 18]
    H = stack(-solve(G_y, G_q), identity(delta))
    # Forward-kinematics Jacobian of the limb, L_p = J_p H
    # [arxiv:2412.13638 eq. 22]
    L_p = J_p(limb, theta) @ H
    # Task-space IK map F = L_t^{-1}, square for non-redundant limbs
    # [arxiv:2412.13681 §4.1]
    F = inverse(L_t(limb, theta))
    # Task-space mass and Coriolis terms, summed over limbs and platform
    # [arxiv:2412.13638 eq. 40–41]
    M_t, C_t = assemble_task_space(limbs, platform, H, F)
    # Feedforward actuator forces; J_IK must be square and invertible
    # [arxiv:2412.13638 eq. 45]
    u = solve(J_IK.T, M_t @ V_dot + C_t @ V_t + W_grav + W - W_ee)
    return u

Notes for implementers:

• The loop residual correction is not in this sketch. The numerical card uses Newton steps until the residual is below ε 2412.13638 alg. 2. The screw card has none, and relies on the linear map 2412.13681 §3.3.2.
• Choice of independent coordinates sets the conditioning of G_y and H, and the numerical card says it is not unique 2412.13638 §3.4 remark.
• Cut-joint numbering in the screw card conflicts between its text and its figure captions, so check the graph before choosing the tree 2412.13681 §3.1.
• The screw card states no tolerance or initial guess for its geometric inverse kinematics 2412.13681 §4.4. The numerical card's examples use ε = 1e-10 2412.13638 §6.4.1.
• Neither card releases code. The screw card's Mathematica model is no longer published, and the numerical card's MATLAB model is not released 2412.13681 §9.1 2412.13638 §6.4.

Contradictions

• Within 2412.13681 §9.1, the text says a closed-form inverse kinematics is not used and an iterative solution is pursued. The same section uses a closed-form loop solution and a closed-form Jacobian.
• Validation against the same commercial multibody tool gives no comparable error figure. The screw card says the trajectories match "up to the prescribed accuracy" 2412.13681 §9.4. The numerical card says the results are validated, with no error metric 2412.13638 §6.4.
• The two cards use different robots, a Delta-type robot with three limbs and a two-degree-of-freedom IRSBot-2 limb. Their timings and iteration counts cannot be compared.

Papers

• Numerical constraint-embedding model for hybrid-limb robots: numerical loop solver with Newton correction, nested and compound inverse kinematics, and a task-space model with feedforward torques.
• Modular screw-theory model for parallel robots with complex limbs: modular screw and Lie-group model, linear loop map, representative-limb reuse, and separable limb terms for parallel evaluation.