In statics, we are interested in configurations where the robot does not accelerate. Instead of writing force/torque balance directly in Cartesian space for each body, we can exploit the principle of virtual work: at equilibrium, the total virtual work done by all forces for any kinematically admissible virtual displacement is zero.

Consider generalized coordinates \( \mathbf{q} \in \mathbb{R}^n \) (joint variables), and a small virtual displacement \( \delta \mathbf{q} \) consistent with the constraints. Let \( \delta W \) denote the total virtual work done by all physical forces and torques. The principle of virtual work states:

\[ \delta W = 0 \quad \text{for all admissible} \ \delta \mathbf{q} \ \text{if and only if the system is in static equilibrium.} \]

In robotic manipulators, admissible virtual displacements respect the joint constraints and rigid-body assumptions. The power of the virtual work principle lies in the fact that we can avoid computing internal constraint forces (e.g., at joints): they do no virtual work along admissible displacements.

flowchart TD
  Q["Joint coordinates q"] --> D["Choose admissible virtual displacement delta_q"]
  D --> K["Use kinematics: delta_x = J(q) * delta_q"]
  K --> W["Compute virtual work of external forces: F^T * delta_x"]
  D --> JT["Joint torques do work: tau^T * delta_q"]
  W --> VW["Total virtual work: tau^T * delta_q - F^T * J * delta_q"]
  JT --> VW
  VW --> EQ["Require zero for all delta_q => tau = J^T * F"]
        

Let \( q_1, \dots, q_n \) be generalized coordinates. An infinitesimal, kinematically admissible virtual displacement is:

\[ \delta \mathbf{q} = \begin{bmatrix} \delta q_1 \\ \vdots \\ \delta q_n \end{bmatrix}. \]

Suppose a set of physical forces/torques acts on the system, and let \( Q_i \) denote the generalized force conjugate to \( q_i \). By definition, the virtual work is

\[ \delta W = \sum_{i=1}^n Q_i \, \delta q_i \;=\; \mathbf{Q}^\mathsf{T} \delta \mathbf{q},\quad \mathbf{Q} = \begin{bmatrix} Q_1 \\ \vdots \\ Q_n \end{bmatrix}. \]

In manipulators with actuated joints, the generalized forces are the joint torques and forces:

\[ \mathbf{Q} = \boldsymbol{\tau} = \begin{bmatrix} \tau_1 \\ \vdots \\ \tau_n \end{bmatrix}. \]

Internal joint reactions (constraint forces between links) generally do no virtual work along admissible \(\delta \mathbf{q}\) and thus do not appear in \(\mathbf{Q}\). This is what allows us to treat a complex multi-body system at the level of generalized coordinates.

From Lesson 1 of this chapter, we use the wrench representation of forces and moments acting on a rigid body:

\[ \mathbf{w} = \begin{bmatrix} \mathbf{f} \\ \mathbf{m} \end{bmatrix} \in \mathbb{R}^6, \]

where \( \mathbf{f} \) is the force and \( \mathbf{m} \) is the moment about some reference point. The dual quantity is the twist, representing linear and angular velocity:

\[ \mathbf{v} = \begin{bmatrix} \boldsymbol{\omega} \\ \mathbf{v}_\ell \end{bmatrix} \in \mathbb{R}^6. \]

The instantaneous power of a wrench acting on a rigid body with twist \( \mathbf{v} \) is given by the dual pairing:

\[ P = \mathbf{w}^\mathsf{T} \mathbf{v} = \mathbf{f}^\mathsf{T} \mathbf{v}_\ell + \mathbf{m}^\mathsf{T} \boldsymbol{\omega}. \]

If we interpret a virtual motion as an infinitesimal displacement in configuration space, the corresponding virtual work over a virtual displacement (without time) becomes:

\[ \delta W = \mathbf{w}^\mathsf{T} \, \delta \mathbf{x}, \]

where \( \delta \mathbf{x} \) is a virtual displacement in task space (e.g., translational and rotational coordinates of the end-effector). This expression is the foundation for relating wrenches to generalized forces via the Jacobian.

Consider an \(n\)-DOF manipulator with generalized coordinates \( \mathbf{q} \in \mathbb{R}^n \). Suppose an external wrench \( \mathbf{w}_e \in \mathbb{R}^6 \) acts at the end-effector (e.g., contact force on a tool), and joint actuators apply torques \( \boldsymbol{\tau} \in \mathbb{R}^n \).

The kinematic relationship between a virtual joint displacement \( \delta \mathbf{q} \) and the corresponding virtual end-effector displacement \( \delta \mathbf{x}_e \in \mathbb{R}^6 \) is (from differential kinematics):

\[ \delta \mathbf{x}_e = \mathbf{J}(\mathbf{q}) \, \delta \mathbf{q}, \]

where \( \mathbf{J}(\mathbf{q}) \in \mathbb{R}^{6 \times n} \) is the end-effector Jacobian (spatial or body, depending on the convention).

The virtual work done by joint torques under \(\delta \mathbf{q}\) is:

\[ \delta W_{\text{joints}} = \boldsymbol{\tau}^\mathsf{T} \, \delta \mathbf{q}. \]

The virtual work done by the end-effector wrench is:

\[ \delta W_{\text{ext}} = \mathbf{w}_e^\mathsf{T} \, \delta \mathbf{x}_e = \mathbf{w}_e^\mathsf{T} \mathbf{J}(\mathbf{q}) \, \delta \mathbf{q}. \]

By the principle of virtual work for an equilibrium configuration:

\[ \delta W_{\text{total}} = \delta W_{\text{joints}} - \delta W_{\text{ext}} = 0 \quad \text{for all admissible} \ \delta \mathbf{q}. \]

Substituting the expressions:

\[ \boldsymbol{\tau}^\mathsf{T} \delta \mathbf{q} - \mathbf{w}_e^\mathsf{T} \mathbf{J}(\mathbf{q}) \delta \mathbf{q} = 0 \quad \text{for all} \ \delta \mathbf{q}. \]

Since this must hold for arbitrary \(\delta \mathbf{q}\), we conclude:

\[ \boldsymbol{\tau} = \mathbf{J}(\mathbf{q})^\mathsf{T} \mathbf{w}_e. \]

This is the fundamental force mapping from Cartesian space (wrench) to joint space (torques) derived purely from statics and virtual work. Lesson 3 will revisit this relation and expand it to more general situations.

Conservative forces admit a potential energy \( U(\mathbf{q}) \). For such forces, the virtual work under a virtual displacement \(\delta \mathbf{q}\) is:

\[ \delta W_{\text{cons}} = - \delta U = - \sum_{i=1}^n \frac{\partial U}{\partial q_i} \, \delta q_i. \]

Therefore, the generalized forces associated with conservative effects are:

\[ Q_i = - \frac{\partial U}{\partial q_i}, \quad \text{or in vector form} \quad \boldsymbol{\tau}_{\text{cons}} = - \nabla_{\mathbf{q}} U(\mathbf{q}). \]

For instance, gravity potential energy \( U_g(\mathbf{q}) \) of all links leads to a gravity torque vector that is the gradient of that potential:

\[ \boldsymbol{\tau}_g(\mathbf{q}) = - \nabla_{\mathbf{q}} U_g(\mathbf{q}). \]

In statics, joint torques at equilibrium must balance both external wrenches (via \(\mathbf{J}^\mathsf{T} \mathbf{w}_e\)) and potential-derived torques \(\boldsymbol{\tau}_g\). The virtual work principle provides a unified way of including both.

Consider a planar 2R manipulator with link lengths \( l_1, l_2 \) and joint angles \( q_1, q_2 \). The end-effector position in the plane is:

\[ \begin{aligned} x(q_1, q_2) &= l_1 \cos q_1 + l_2 \cos(q_1 + q_2), \\ y(q_1, q_2) &= l_1 \sin q_1 + l_2 \sin(q_1 + q_2). \end{aligned} \]

The translational Jacobian \( \mathbf{J}_p(\mathbf{q}) \in \mathbb{R}^{2 \times 2} \) is:

\[ \mathbf{J}_p(\mathbf{q}) = \begin{bmatrix} \dfrac{\partial x}{\partial q_1} & \dfrac{\partial x}{\partial q_2} \\ \dfrac{\partial y}{\partial q_1} & \dfrac{\partial y}{\partial q_2} \end{bmatrix} = \begin{bmatrix} -l_1 \sin q_1 - l_2 \sin(q_1 + q_2) & -l_2 \sin(q_1 + q_2) \\ \phantom{-}l_1 \cos q_1 + l_2 \cos(q_1 + q_2) & \phantom{-}l_2 \cos(q_1 + q_2) \end{bmatrix}. \]

Suppose a planar force \( \mathbf{f}_e = [f_x, f_y]^\mathsf{T} \) acts at the end-effector (no moment about the out-of-plane axis). The corresponding joint torques are:

\[ \boldsymbol{\tau} = \mathbf{J}_p(\mathbf{q})^\mathsf{T} \mathbf{f}_e. \]

Explicitly:

\[ \begin{aligned} \tau_1 &=& \left(-l_1 \sin q_1 - l_2 \sin(q_1 + q_2)\right) f_x + \left(l_1 \cos q_1 + l_2 \cos(q_1 + q_2)\right) f_y, \\ \tau_2 &=& \left(-l_2 \sin(q_1 + q_2)\right) f_x + \left(l_2 \cos(q_1 + q_2)\right) f_y. \end{aligned} \]

These expressions are precisely those obtained by balancing moments about each joint, but here they fall out systematically from the virtual work principle and the Jacobian.

We now implement the mapping \( \boldsymbol{\tau} = \mathbf{J}^\mathsf{T} \mathbf{w}_e \) for the planar 2R arm in different programming languages. For general \(n\)-DOF robots, the code structure is similar: compute \( \mathbf{J}(\mathbf{q}) \), then apply the transpose to the wrench vector.

7.1 Python (NumPy, symbolic option)

import numpy as np

def jacobian_2r(q, l1, l2):
    q1, q2 = q
    s1 = np.sin(q1)
    c1 = np.cos(q1)
    s12 = np.sin(q1 + q2)
    c12 = np.cos(q1 + q2)

    J = np.array([
        [-l1*s1 - l2*s12, -l2*s12],
        [ l1*c1 + l2*c12,  l2*c12]
    ])
    return J

def joint_torques_from_force(q, l1, l2, f):
    """
    q  : array-like of shape (2,)  [q1, q2]
    l1,l2 : link lengths
    f  : array-like of shape (2,)  [fx, fy]
    returns tau : np.array shape (2,)
    """
    J = jacobian_2r(q, l1, l2)
    f_vec = np.asarray(f).reshape(2,)
    tau = J.T @ f_vec
    return tau

if __name__ == "__main__":
    q = np.deg2rad([45.0, 30.0])
    l1, l2 = 1.0, 0.8
    f = np.array([10.0, 0.0])  # force in x-direction
    tau = joint_torques_from_force(q, l1, l2, f)
    print("Joint torques:", tau)
      

For more complex robots, a Python robotics library like roboticstoolbox-python can generate Jacobians automatically from a kinematic model; the same virtual-work mapping then applies.

7.2 C++ (Eigen, with note on KDL)

#include <iostream>
#include <Eigen/Dense>

Eigen::Matrix2d jacobian2R(double q1, double q2, double l1, double l2) {
    double s1 = std::sin(q1);
    double c1 = std::cos(q1);
    double s12 = std::sin(q1 + q2);
    double c12 = std::cos(q1 + q2);

    Eigen::Matrix2d J;
    J(0,0) = -l1*s1 - l2*s12;
    J(0,1) = -l2*s12;
    J(1,0) =  l1*c1 + l2*c12;
    J(1,1) =  l2*c12;
    return J;
}

Eigen::Vector2d jointTorquesFromForce(double q1, double q2,
                                      double l1, double l2,
                                      double fx, double fy) {
    Eigen::Matrix2d J = jacobian2R(q1, q2, l1, l2);
    Eigen::Vector2d f(fx, fy);
    return J.transpose() * f;
}

int main() {
    double q1 = M_PI/4.0;
    double q2 = M_PI/6.0;
    double l1 = 1.0, l2 = 0.8;
    double fx = 10.0, fy = 0.0;

    Eigen::Vector2d tau = jointTorquesFromForce(q1, q2, l1, l2, fx, fy);
    std::cout << "tau = " << tau.transpose() << std::endl;
    return 0;
}
      

In larger C++ projects, the Kinematics and Dynamics Library (KDL) can be used to compute Jacobians from URDF or chain definitions; again the virtual work mapping is implemented via tau = J.transpose() * wrench.

7.3 Java (plain arrays)

public class Planar2RVirtualWork {

    public static double[][] jacobian2R(double q1, double q2, double l1, double l2) {
        double s1 = Math.sin(q1);
        double c1 = Math.cos(q1);
        double s12 = Math.sin(q1 + q2);
        double c12 = Math.cos(q1 + q2);

        double[][] J = new double[2][2];
        J[0][0] = -l1 * s1 - l2 * s12;
        J[0][1] = -l2 * s12;
        J[1][0] =  l1 * c1 + l2 * c12;
        J[1][1] =  l2 * c12;
        return J;
    }

    public static double[] jointTorquesFromForce(double q1, double q2,
                                                 double l1, double l2,
                                                 double fx, double fy) {
        double[][] J = jacobian2R(q1, q2, l1, l2);
        double[] tau = new double[2];
        tau[0] = J[0][0]*fx + J[1][0]*fy;
        tau[1] = J[0][1]*fx + J[1][1]*fy;
        return tau;
    }

    public static void main(String[] args) {
        double q1 = Math.PI/4.0;
        double q2 = Math.PI/6.0;
        double l1 = 1.0, l2 = 0.8;
        double fx = 10.0, fy = 0.0;

        double[] tau = jointTorquesFromForce(q1, q2, l1, l2, fx, fy);
        System.out.println("tau1 = " + tau[0] + ", tau2 = " + tau[1]);
    }
}
      

7.4 MATLAB / Simulink

function tau = joint_torques_from_force_2r(q, l1, l2, f)
% q  : [q1; q2]
% l1 : link 1 length
% l2 : link 2 length
% f  : [fx; fy]

q1 = q(1);
q2 = q(2);
fx = f(1);
fy = f(2);

s1  = sin(q1);
c1  = cos(q1);
s12 = sin(q1 + q2);
c12 = cos(q1 + q2);

J = [ -l1*s1 - l2*s12,  -l2*s12;
       l1*c1 + l2*c12,   l2*c12 ];

tau = J.' * f;
end

% Example call:
% q = deg2rad([45; 30]);
% l1 = 1.0; l2 = 0.8;
% f = [10; 0];
% tau = joint_torques_from_force_2r(q, l1, l2, f)
      

In Simulink, this function can be used inside a MATLAB Function block with inputs \( \mathbf{q} \) and \( \mathbf{f} \) to output \( \boldsymbol{\tau} \). A static analysis model can consist of blocks computing the Jacobian from joint angles and then applying a matrix transpose and multiplication.

7.5 Wolfram Mathematica

(* Define symbolic variables *)
Clear[q1, q2, l1, l2, fx, fy];
Jp = {
  {-l1*Sin[q1] - l2*Sin[q1 + q2], -l2*Sin[q1 + q2]},
  { l1*Cos[q1] + l2*Cos[q1 + q2],  l2*Cos[q1 + q2]}
};

f = {fx, fy};
tau = Transpose[Jp].f // Simplify

(* Substitute numerical values *)
tauNum = tau /. {
   q1 -> Pi/4, q2 -> Pi/6,
   l1 -> 1.0, l2 -> 0.8,
   fx -> 10.0, fy -> 0.0
} // N
      

Mathematica is particularly convenient for symbolic derivations of Jacobians and torque expressions; these can then be exported as optimized code for other languages.

In this lesson we introduced the principle of virtual work for robotic manipulators. Using generalized coordinates and admissible virtual displacements, we defined generalized forces and showed how constraint forces disappear from the virtual work balance. For rigid-body robots with known Jacobians, we derived the central statics relation \( \boldsymbol{\tau} = \mathbf{J}^\mathsf{T} \mathbf{w}_e \), and we connected conservative forces to potential energy via \( \boldsymbol{\tau} = -\nabla_{\mathbf{q}} U(\mathbf{q}) \). A planar 2R example illustrated explicit torque expressions and numerical evaluation. Programming labs in Python, C++, Java, MATLAB/Simulink, and Mathematica demonstrated how the virtual work mapping is implemented in practice. The next lesson will build on this foundation to study wrench transmission and Jacobian-transpose force control more systematically.