Mastering Torque and Angular Momentum in Robotic Applications#

Definition and Units#

Torque (τ) is the rotational equivalent of force. It measures the tendency of a force to rotate an object about an axis. Mathematically, torque can be expressed as:

τ = r × F

where:

• r is the position vector from the pivot point (axis of rotation) to the point of application of the force.
• F is the force vector.
• × denotes the vector cross product.

In more general terms, you often see:

τ = r · F · sin(θ)

where θ is the angle between r and F. The SI unit of torque is the Newton-meter (N·m).

Intuitive Understanding#

• If you push on a door closer to its hinges, it is harder to open because the moment arm (radius, r) is smaller, thus reducing torque.
• If you push at the exact center of a wrench, you provide less torque than when you push at its very end. Increasing the length of the lever arm increases torque.

Definition#

Angular momentum (L) is to rotational motion what linear momentum (p) is to translational motion. For a rotating rigid body with moment of inertia I and angular velocity ω:

L = Iω

For a point mass m moving with velocity v at a perpendicular distance r from the axis of rotation, the definition is:

L = r × p = m (r × v)

where p = mv is the linear momentum.

Conservation#

In an isolated system (with no external torques), the total angular momentum remains constant. This principle is extremely evident in spinning objects such as flywheels, spinning drones, and robotic arms handling inertia effects.

Significance in Robotics#

Moment of inertia (I) measures how mass is distributed relative to an axis of rotation. Different shapes have different moments of inertia. If a robot’s link is heavier at its edges rather than near its joints, it will have a higher moment of inertia about its axis.

Common Formulas#

Below is a small table with conventional moment of inertia formulas for some standard shapes about their central axis:

Robotic designers routinely perform moment of inertia calculations to ensure their actuators can safely provide enough torque.

Robotic Arms#

A typical robotic arm has multiple segments (links) connected by joints. Each joint must generate enough torque to move its link(s) plus any payload at the desired angular acceleration. Key considerations include:

1. Weight of the arm segments and payload.
2. Distribution of mass (moment of inertia).
3. Desired angular velocity and acceleration.
4. Number of links, since torque in an upstream joint may carry the load of all subsequent links.

Mobile Robots#

Torque also applies to wheel-based robots, which rely on rotational motion to propel themselves. A motor exerts torque on the vehicle’s wheels. The classical relationship for rotational motion—�?= Iα—tells you how fast the wheel will change its rotational speed in response to a given torque.

Drones and Aerial Vehicles#

In quadcopters, adjusting the individual motor torques changes the angular momentum of the drone’s entire body. This technique allows the drone to tilt, yaw, pitch, and roll, controlling its orientation in three-dimensional space.

PID Control for Rotational Systems#

A PID (Proportional-Integral-Derivative) controller attempts to regulate torque to maintain or change angular velocity to match a reference. For rotation, you can think of the “error�?as the difference between desired and actual angular position or velocity.

• Proportional Term (P): Generates a torque proportional to the instantaneous error.
• Integral Term (I): Accumulates the past error over time, compensating for persistent offsets.
• Derivative Term (D): Looks at the error rate of change, providing dampening.

Feedforward Compensation#

In advanced robotics, feedforward terms are often used to anticipate the torque required. By modeling the system’s dynamics (including inertia and friction), a robot can output a near-ideal torque command before significant error accumulates.

Python Examples#

1
import math
2

3
def required_torque(mass, radius, angular_acc):
4
    """
5
    Calculates the torque required to rotate a point mass at a given angular acceleration.
6
    mass: in kg
7
    radius: in m
8
    angular_acc: in rad/s^2
9
    """
10
    I = mass * (radius ** 2)  # moment of inertia for point mass
11
    torque = I * angular_acc
12
    return torque
13

14
mass = 2.0  # kg
15
radius = 0.15  # m
16
angular_acc = 2.0  # rad/s^2
17

18
needed_torque = required_torque(mass, radius, angular_acc)
19
print(f"Required Torque: {needed_torque:.4f} N·m")

1
import time
2

3
class SimpleRotationalSystem:
4
    def __init__(self, I):
5
        self.I = I          # Moment of inertia
6
        self.theta = 0.0    # Current angle in radians
7
        self.omega = 0.0    # Current angular velocity
8
        self.torque = 0.0   # Current applied torque
9

10
    def update(self, dt):
11
        # Angular acceleration = torque / I
12
        alpha = self.torque / self.I
13
        self.omega += alpha * dt
14
        self.theta += self.omega * dt
15

16
def simulate_pid(I, target_angle, Kp, Ki, Kd, sim_time=2.0, dt=0.01):
17
    system = SimpleRotationalSystem(I)
18
    integral = 0.0
19
    prev_error = target_angle - system.theta
20

21
    steps = int(sim_time / dt)
22
    for i in range(steps):
23
        error = target_angle - system.theta
24
        integral += error * dt
25
        derivative = (error - prev_error) / dt
26

27
        # PID Output
28
        system.torque = Kp * error + Ki * integral + Kd * derivative
29

30
        # Update system
31
        system.update(dt)
32

33
        prev_error = error
34
        time_current = (i+1) * dt
35
        print(f"Time={time_current:.2f}, Angle={system.theta:.3f}, Torque={system.torque:.3f}")
36

37
# Example usage
38
simulate_pid(I=0.02, target_angle=1.57, Kp=10.0, Ki=2.0, Kd=0.5)

C++ Code Snippets#

For embedded systems or performance-critical robotics, C++ is popular. Here are a couple of short examples.

1
#include <iostream>
2
#include <cmath>
3

4
double computeTorque(double mass, double radius, double alpha) {
5
    double I = mass * std::pow(radius, 2);
6
    return I * alpha;
7
}
8

9
int main() {
10
    double mass = 2.0;
11
    double radius = 0.15;
12
    double angular_acc = 2.0;
13

14
    double torque = computeTorque(mass, radius, angular_acc);
15
    std::cout << "Required Torque: " << torque << " N·m" << std::endl;
16
    return 0;
17
}

1
#include <iostream>
2
#include <vector>
3

4
// A simple representation of a robotic link
5
struct Link {
6
    double I;    // moment of inertia
7
    double theta; // current angle
8
    double omega; // angular velocity
9
    double torque; // required torque
10
};
11

12
// Forward dynamics for multiple links (very simplified)
13
void forwardDynamics(std::vector<Link>& links, double dt) {
14
    for (auto &link : links) {
15
        // angular acceleration = torque / I
16
        double alpha = link.torque / link.I;
17
        link.omega += alpha * dt;
18
        link.theta += link.omega * dt;
19
    }
20
}
21

22
int main() {
23
    // Suppose we have a two-link system
24
    std::vector<Link> robot = {
25
        {0.02, 0.0, 0.0, 0.0}, // Link 1
26
        {0.015, 0.0, 0.0, 0.0} // Link 2
27
    };
28

29
    // Desired torques for demonstration
30
    robot[0].torque = 0.3;
31
    robot[1].torque = 0.2;
32

33
    double dt = 0.01;
34
    for (int i = 0; i < 100; i++) {
35
        forwardDynamics(robot, dt);
36
        std::cout << "Time: " << i*dt
37
                  << " Link1 Theta: " << robot[0].theta
38
                  << " Link2 Theta: " << robot[1].theta << std::endl;
39
    }
40

41
    return 0;
42
}

Euler-Lagrange Formalism#

The Euler-Lagrange approach is often used to derive the equations of motion for multi-joint robots. It provides a systematic method:

1. Define generalized coordinates (joint angles).
2. Write expressions for the kinetic (T) and potential (V) energies in terms of these coordinates.
3. Use the Lagrangian (L = T - V).
4. Apply Euler-Lagrange equations:

d/dt(∂L/∂q̇_i) - (∂L/∂q_i) = τ_i

where q_i is the i-th generalized coordinate, and τ_i is the torque corresponding to that joint.

Coriolis and Centrifugal Effects#

When multiple joints move simultaneously, Coriolis and centrifugal terms appear in the equations of motion. These terms can cause “coupling”—torque applied at one joint might affect the angular acceleration at another joint. Properly dealing with these effects requires advanced control strategies or feedforward compensation.

1. Model Predictive Control (MPC)#

Model Predictive Control uses an internal model of the system (including its inertia, friction, Coriolis effects, etc.) to predict future states and optimize control actions over a prediction horizon. This is particularly powerful when dealing with systems that have constraints (motor torque limits, joint angle limits, etc.). By solving an optimization problem repeatedly in real-time, MPC can produce smooth, effective torque commands.

2. Adaptive Control#

Robotic systems operating in unstructured environments or with variable payloads benefit from adaptive control. These strategies adjust their parameters (e.g., estimated mass or friction) online to reduce model mismatch and maintain precise torque control.

3. Impedance and Admittance Control#

When a robot needs to interact with humans or objects safely, impedance or admittance control can modulate how stiffly the robot reacts to external forces. This is effectively adjusting how the robot’s torque responds when external torques are sensed.

• Impedance Control: Robot adjusts its motion based on external forces to feel “softer�?or “stiffer.�?
• Admittance Control: The robot changes position in response to externally applied force, sometimes more intuitive for physically interactive tasks.

4. Redundancy Resolution#

High-DOF robots may have more joints than are strictly necessary for a given task. One can leverage this redundancy to optimize secondary criteria (e.g., avoiding joint limits or minimizing torque usage). Advanced algorithms compute joint torques that accomplish both the primary task (like positioning the end effector) and additional objectives.

5. High-Frequency Torque Control#

For rapidly moving robots, timing is critical. Actuators must be capable of high update rates to achieve accurate torque control. Highly dynamic robots (e.g., humanoids, legged robots) can operate with torque control loops of 1kHz or higher, often powered by specialized real-time hardware.