Newton-Euler Dynamics: Forces, Torques, and Rigid Bodies
Every dynamic model starts with F = ma — the art is accounting for all the forces your model ignores.
🎯 By the end you'll understand
How Newton's second law extends to rigid bodies in full 6-DOF (linear and angular momentum). What the inertia tensor is and why its off-diagonal terms bite you. How the Newton-Euler recursive algorithm propagates forces and torques through a serial chain. Where Coriolis and centrifugal terms come from physically (they are not just "extra math"). Why the gap between your dynamic model and real hardware is an engineering problem that lives in Stage 3, not deferred to later. And what happens when you forget to include the battery mass in the inertia tensor.
KEY INSIGHTKinematics tells you where; dynamics tells you why it got there
A kinematic model of FollowBot's arm tells you that joint 2 must rotate 37° to reach the target. A dynamic model tells you exactly how much torque joint 2's motor must produce — accounting for the weight of everything downstream, the angular acceleration you commanded, and the Coriolis load from joint 1 moving simultaneously.
Stage 2 was about geometry: coordinate frames, transforms, the Jacobian. It answered "where is the end-effector if I set these joint angles?" That is a pure constraint question. Stage 3 is about forces. It answers "what torques must the motors produce to execute a desired trajectory?" That is a physics question, and physics has terms that geometry ignores: mass distribution, rotational inertia, fictitious forces from rotating frames, friction, and compliance. Every term you omit becomes a tracking error in your real robot.
A perfectly accurate dynamic model is computationally intractable — you'd need to account for every gear tooth, cable bend, and deforming link. A perfectly tractable model (F = ma applied to a point mass at the end-effector) is physically wrong enough to destabilize a real controller. The Newton-Euler formulation hits the sweet spot: it is exact for rigid-body assumptions and scales linearly in the number of joints. Understanding where those assumptions fail is the engineering skill this lesson teaches.
CORE CONCEPTRigid-body equations of motion
For a point mass, Newton's law is simply f = ma. For a rigid body — an object with extent, not just a point — there are two coupled equations: one for linear momentum and one for angular momentum. Together they are called the Newton-Euler equations.
Let the body have mass m, center of mass position p in an inertial frame, and angular velocity ω expressed in the body frame. The translational equation is:
f = m · ac where ac is the linear acceleration of the center of mass. Every external force acting on the body — gravity, contact forces, motor-shaft loads — contributes to f. This looks identical to point-mass dynamics, because for translation purposes the entire mass acts at the center of mass.
The rotational equation — Euler's equation of motion — is more interesting:
τ = I · α + ω × (I · ω)
where τ is the net torque, I is the 3×3 inertia tensor, α = dω/dt is angular acceleration, and ω × (I · ω) is the Coriolis/gyroscopic term. The second term is zero only when ω = 0 or when ω is aligned with a principal axis of I. For a spinning arm link that is simultaneously rotating at the base, this term is never zero and can be the dominant load on a joint motor.
What makes this hard in practice is that both equations must be expressed in consistent frames, and the coupling between them (the fact that forces from one link propagate as loads to the next) requires a systematic bookkeeping algorithm — which is exactly what Newton-Euler recursion provides.
CORE CONCEPTThe inertia tensor: mass distribution matters
For a point mass, the resistance to angular acceleration is just mr² (scalar). For a rigid body, it is a 3×3 matrix — the inertia tensor I — because the resistance depends on both the axis of rotation and how mass is distributed in 3D. In the body frame:
| Component | Physical meaning | Practical implication |
|---|---|---|
| Ixx, Iyy, Izz (diagonal) | Resistance to rotation about x, y, z respectively. Sum of (mass × perpendicular distance²) for all mass elements. | A long, thin link has a small Ixx (about its length axis) but large Iyy, Izz. Motor must work harder to rotate about the latter axes. |
| Ixy, Ixz, Iyz (off-diagonal) | Products of inertia — measure asymmetric mass distribution. Zero only when body has symmetry about the coordinate planes. | Non-zero products couple rotation axes. A torque about x also tends to spin the body about y. Causes unexpected cross-axis loads in joint actuators. |
| Principal axes | The frame in which I is diagonal — found by eigenvector decomposition. The Euler equation simplifies considerably in this frame. | CAD software reports inertia in the principal frame. ROS URDF expects inertia in the link frame — you must transform between them. |
In a URDF file, you specify the inertia tensor for each link in the <inertial> tag. Getting these numbers wrong is one of the most common and hardest-to-diagnose bugs in robot simulation:
<link name="link_2"> <inertial> <origin xyz="0.12 0.0 0.0" rpy="0 0 0"/> <!-- CoM offset from joint --> <mass value="0.85"/> <!-- kg --> <inertia ixx="0.003" ixy="0.0" ixz="0.0" iyy="0.018" iyz="0.0" izz="0.018"/> </inertial> <!-- These values from CAD (kg·m²); real robot: verify on a swing-table --> </link>
The URDF origin in the <inertial> element is critical: it sets the point about which the inertia tensor is defined (the CoM). If you accidentally set it to the joint origin instead of the CoM, you get the wrong inertia by the parallel axis theorem: Ijoint = ICoM + m·d², where d is the distance from CoM to joint. For a 0.85 kg link with CoM 0.12 m from the joint, this error adds 0.012 kg·m² to Iyy — a 67% error in this example.
HOW IT WORKSNewton-Euler recursive algorithm for serial chains
A robot arm is not a single body — it is a chain of bodies connected at joints. Forces and torques cascade: the end-effector load becomes a force on link N, which becomes a torque demand on joint N, which becomes a force on link N-1, and so on back to the base. The Newton-Euler recursive algorithm formalizes this in two sweeps.
Outward sweep: propagate velocities and accelerations (base → tip)
Starting from the base (joint 1), compute the angular velocity ωi and linear acceleration of the CoM ac,i for each link i, using the joint velocity θ̇i and the transform from the previous link's frame. For a revolute joint i with axis ẑi:
ωi = ωi-1 + θ̇i · ẑi
αi = αi-1 + θ̈i · ẑi + ωi-1 × (θ̇i · ẑi)
The third term in the angular acceleration — ωi-1 × (θ̇i · ẑi) — is the Coriolis acceleration. It is zero only if the robot is not already rotating. For a 6-DOF arm moving at speed, all six joints contribute Coriolis terms simultaneously.
Inward sweep: propagate forces and torques (tip → base)
Starting from the tip (link N), apply Newton's law to get the net force fi on each link. Then apply Euler's equation to get the net torque ni. The joint torque τi is the component of ni along the joint axis:
fi = mi · ac,i
ni = Ii · αi + ωi × (Ii · ωi) + pc,i × fi
τi = ni · ẑi (ni already incorporates ni+1 from the previous recursive step — do not add ni+1 separately)
The term pc,i × fi is the moment arm: the cross product of the CoM position vector with the linear force. This is where mass placement directly affects torque requirements — and where a misplaced battery destroys your model.
The result: the equation of motion in matrix form
After running Newton-Euler recursion symbolically (not numerically), you obtain the robot's equation of motion in its canonical form:
τ = M(q) · q̈ + C(q, q̇) · q̇ + g(q)
Where M(q) is the configuration-dependent mass matrix (inertia), C(q, q̇) · q̇ collects all Coriolis and centrifugal terms, and g(q) is the gravity vector. This is the equation you will use in Lesson 3.3 to build a feedforward controller: given a desired trajectory q, q̇, q̈, you can compute the exact joint torques τ required — assuming your model is correct.
The Lagrangian formulation (Lesson 3.2) derives the same equation of motion from energy principles rather than force balance. Newton-Euler is computationally efficient (O(N) in the number of joints for numerical simulation), which is why industrial robot controllers use it at runtime. Lagrangian is analytically cleaner for deriving symbolic expressions and understanding structure. You should know both — but Newton-Euler is the one running inside your actual robot controller.
CORE CONCEPTCoriolis and centrifugal terms — physical intuition
These terms consistently confuse people because they appear in the math before the physical intuition is clear. Here is the intuition.
Centrifugal term: When a link rotates, its mass wants to fly outward. The joint must exert an inward centripetal force to keep the link on its circular path. This force does not point along the joint axis — it creates a torque on upstream joints. For joint i rotating at rate θ̇i, the centrifugal load on joint i-1 is proportional to θ̇i². At low speeds this is negligible; at high speeds it dominates the gravity term.
Coriolis term: When two joints rotate simultaneously, the velocity of a downstream link as seen from an upstream rotating frame is not just the sum of the two velocities — there is a cross-coupling that creates an additional acceleration. This is exactly the Coriolis effect from classical mechanics. The Coriolis torque on joint i due to the simultaneous motion of joint j is proportional to θ̇i · θ̇j. For a robot arm with 6 joints all moving simultaneously, there are 6×5/2 = 15 Coriolis cross-terms. Ignoring them in a fast manipulation task produces systematic tracking errors that PID cannot eliminate — because PID is reactive (corrects after the error appears) while Coriolis loads appear instantaneously from velocity.
A PID controller can track a slowly moving trajectory despite Coriolis and centrifugal terms, because these terms produce errors that the PID integrator eventually corrects. But the correction is always delayed, which means the tracking error during fast movements is large. Feedforward control computes the Coriolis and centrifugal torques analytically using the equation of motion and adds them to the motor command before the error appears. This is the core payoff of building the dynamic model. Lesson 3.3 derives the feedforward controller; Lesson 3.4 closes the loop with PID plus feedforward.
SEE ITNewton-Euler single-link force/torque visualizer
A single rigid arm link pinned at its left end. Use the controls to set the link angle, angular velocity, mass, and inertia. Then toggle gravity and add a mass offset (simulating a battery mounted off-center). The widget computes and draws the force/torque at the joint using Newton-Euler equations and shows the readout. The goal: find the configuration that maximizes joint torque demand — and understand why the battery offset makes it worse.
Notice that the maximum torque demand occurs at θ = 0 (link horizontal) when gravity fully acts perpendicular to the link. At θ = ±90° (link vertical), gravity acts along the link and produces zero torque — but the centrifugal term (proportional to ω²) still loads the joint. The battery offset shifts the center of mass outward, increasing the moment arm for gravity and amplifying both the gravity and centrifugal loads.
FOLLOWBOTDeriving the arm dynamics
FollowBot's 6-DOF arm extends the mobile base to enable handoffs and gesture responses. Stage 3's milestone requires a full dynamics model for the arm — this is where we start building it.
The arm is a serial chain of 6 revolute joints. Newton-Euler recursion applies directly. For the inverse dynamics problem (computing joint torques given a desired trajectory), we implement the outward-inward sweep in Python using rclpy. The dynamics are packaged as a ROS 2 service that the controller calls at each time step:
import numpy as np import rclpy from rclpy.node import Node from followbot_msgs.srv import InverseDynamics # Physical parameters for FollowBot's arm (from CAD + swing-table measurements) G = 9.81 # m/s² N_JOINTS = 6 MASSES = [0.85, 0.72, 0.61, 0.40, 0.28, 0.15] # kg per link COM_OFFSETS = [0.12, 0.10, 0.08, 0.06, 0.05, 0.03] # m from joint to CoM # Inertia tensors (diagonal principal values, kg·m²) — from SolidWorks export INERTIAS = [ [0.003, 0.018, 0.018], # link 1 [0.002, 0.014, 0.014], # link 2 [0.001, 0.009, 0.009], # ... etc. [0.0008, 0.005, 0.005], [0.0005, 0.003, 0.003], [0.0002, 0.001, 0.001], ] class ArmDynamicsNode(Node): def __init__(self): super().__init__('arm_dynamics') self.create_service( InverseDynamics, '/arm/inverse_dynamics', self.handle_inv_dyn ) self.get_logger().info('Arm dynamics service ready') def handle_inv_dyn(self, req, resp): # req: q (joint angles), qd (velocities), qdd (accelerations) q = np.array(req.q) qd = np.array(req.qd) qdd = np.array(req.qdd) resp.tau = newton_euler_id(q, qd, qdd).tolist() return resp def newton_euler_id(q, qd, qdd): # Simplified 2D Newton-Euler for illustration; full 3D version uses SE(3) tau = np.zeros(N_JOINTS) # Outward sweep: build link accelerations omega_prev = 0.0 alpha_prev = 0.0 for i in range(N_JOINTS): omega_i = omega_prev + qd[i] alpha_i = alpha_prev + qdd[i] + omega_prev * qd[i] # Coriolis term omega_prev = omega_i; alpha_prev = alpha_i # Inward sweep: compute joint torques (gravity + inertia + centrifugal) for i in reversed(range(N_JOINTS)): Lc = COM_OFFSETS[i] m = MASSES[i] Izz = INERTIAS[i][2] # gravity torque (max when link horizontal) tau[i] += m * G * Lc * np.cos(q[i]) # inertial torque tau[i] += Izz * qdd[i] + m * Lc**2 * qdd[i] # centrifugal coupling from next joint (simplified) if i < N_JOINTS - 1: tau[i] += m * Lc * qd[i+1]**2 return tau def main(): rclpy.init() rclpy.spin(ArmDynamicsNode()) rclpy.shutdown() if __name__ == '__main__': main()
The full dynamics model for FollowBot's arm is derived in Stage 3. The complete milestone deliverables are: (1) URDF inertial parameters verified against swing-table measurements for all 6 links; (2) this arm_dynamics service running in Gazebo, producing joint torques that match Gazebo's ground-truth within 5%; (3) a PID velocity controller tuned to a settling-time spec using Ziegler-Nichols initial gains (Lesson 3.4); (4) feedforward from inverse dynamics reducing steady-state tracking error below 2° at 1 Hz motion (Lesson 3.3); (5) a figure-eight end-effector trajectory tracked with measured cross-track error below 5 mm (Lesson 3.7).
One critical measurement before this service can be trusted: the battery. FollowBot's arm mounts a 250 g LiPo cell to link 2 for distributed power delivery. The default URDF has the battery modeled as part of link 2's uniform mass — but the physical cell sits 80 mm off the neutral axis. The effect in the widget above shows this precisely: an off-center mass shifts the CoM, increases the moment arm for gravity, and changes the direction of the gravity vector in the body frame. The result is a systematic torque underestimate of approximately 0.8 N·m at full extension — enough to cause the arm to droop 3–5° on the trajectory. This is the failure mode the SPEC brief flags; it surfaces in Lesson 3.3 when the feedforward controller's tracking error is unexpectedly large.
IN PRACTICEThe model vs. hardware gap
The Newton-Euler formulation makes strong assumptions. Understanding which ones are violated by your specific hardware is how you move from textbook to functioning robot.
| Model assumption | Real-hardware violation | Effect on controller | Mitigation |
|---|---|---|---|
| Links are perfectly rigid | Long links flex under load; gearboxes have compliance | Structural resonance modes; position error at tip is larger than at joint encoder | Modal analysis; notch filters at resonant frequency; lower bandwidth |
| Joints are frictionless | Coulomb + viscous friction, Stribeck curve at low velocities | Position deadband at slow speeds; velocity reversal delay; integrator windup | Friction identification + compensation (add ĝ_friction to feedforward) |
| Mass model is correct | Cable routing, battery placement, end-effector payload vary | Wrong g(q) → systematic torque error → tracking error proportional to cos(joint angle) | Accurate CAD + swing-table measurement; adaptive dynamics identification |
| Actuators are torque sources | Real motors have bandwidth limits, back-EMF, current limits | Fast trajectory segments saturate the torque command → tracking error during peaks | Torque saturation model; trajectory replanning to stay within actuator bandwidth |
| No unmodelled masses | Battery (250 g), cable harness (~150 g), grippers vary by payload | CoM shifts from nominal → gravity vector direction error in body frame | Model all mounted components explicitly; use inertial measurement rig for verification |
The sim-to-real gap in dynamics is quantitatively different from the sim-to-real gap in perception. A perception gap (lighting, texture) can often be bridged by randomization. A dynamics gap produces systematic torque errors — they are not random, they have a predictable structure (proportional to cos(angle) for gravity errors, proportional to ω² for friction errors). This means you can identify them from data and compensate them explicitly. This is the subject of adaptive control and system identification, introduced in Lesson 3.6.
WEAKNESSWhere this bites
This is the failure mode the brief flags — and it is common enough to name explicitly. FollowBot's arm mounts a 250 g LiPo cell on link 2, approximately 80 mm from the neutral axis. If the URDF lumps this mass into the uniform-cylinder model for link 2 (common when copying template URDFs), the modeled CoM sits at the geometric center, but the real CoM is shifted toward the battery side. The gravity vector in the body frame now points in a slightly wrong direction. The resulting torque error at link 2's joint is approximately m_battery × g × offset = 0.25 × 9.81 × 0.08 ≈ 0.20 N·m. That looks small — but it is constant and systematic, which means the PID integrator must permanently wind up to compensate. The integrator windup slows response on direction reversals, which appears as a position overshoot. The root cause is not the controller — it is an unmodelled mass. The fix is to model the battery explicitly as a separate inertial element in the URDF.
A common simplification: set the C(q, q̇) · q̇ term to zero because the robot is "moving slowly." The problem is that Coriolis loads are proportional to θ̇i · θ̇j — the product of joint velocities, not the magnitude of any single joint's velocity. A 6-DOF arm with all six joints moving at 0.5 rad/s each produces Coriolis loads proportional to 0.5 × 0.5 = 0.25 (rad/s)² across all 15 joint pairs. For a link mass of 0.8 kg at 0.12 m radius, that is approximately 0.8 × 0.12² × 0.25 = 0.0029 N·m per pair — seemingly small, but it accumulates over 15 pairs and becomes meaningful at the proximal joints. For a figure-eight trajectory (constant speed but continuously changing direction), all joints move simultaneously and the Coriolis load is never zero. Ignoring it produces a constant cross-track error proportional to the product of joint velocities — one that PID cannot eliminate because it appears instantaneously (PID is reactive; Coriolis is instantaneous). The fix is feedforward, not more PID gain.
CAD software exports inertia tensors — but those values reflect the nominal geometry, not the as-built part. Machined tolerances, surface finishes, fasteners, and adhesives all shift the real mass distribution from the CAD model. For link 1 of FollowBot's arm (the heaviest, at 850 g), a 5% error in Izz propagates as a 5% error in the inertial torque term M(q) · q̈. At an angular acceleration of 5 rad/s², the error in joint torque is approximately 0.05 × 0.018 × 5 = 0.0045 N·m — negligible in isolation. But the gravity term g(q) at 90° extension is about 0.85 × 9.81 × 0.12 = 1.0 N·m, and a 2 mm CoM offset error (easily achievable in casting) shifts this by 0.85 × 9.81 × 0.002 = 0.017 N·m. The lesson: verify inertial parameters on the physical robot, not just in CAD. The swing-table method (suspend the link and measure oscillation period) gives I to within ~2%.
KEY INSIGHTHow it connects
- 2.3 · Forward Kinematics and Denavit-Hartenberg Parameters — the DH parameters define the transform chain that Newton-Euler recursion walks during the outward sweep. Without the correct joint frames and link lengths, the propagation of velocities and accelerations is wrong before the dynamics computation even begins.
- 2.4 · The Jacobian: Velocity Kinematics and the Spine of Robotics — the Jacobian maps joint velocities to end-effector velocity. It also appears in the Coriolis term (implicitly): the C(q, q̇) matrix is related to the time derivative of the mass matrix M(q), which involves the Jacobian. For operational-space control (Lesson 3.7), the Jacobian and the dynamic model are coupled explicitly.
- 3.2 · Lagrangian Dynamics: Energy Methods and the Equation of Motion — the Lagrangian formulation derives the same M(q) · q̈ + C(q, q̇) · q̇ + g(q) = τ from a different angle (energy vs. force balance). Understanding both gives you the ability to pick the right tool: Newton-Euler for efficient numerical computation, Lagrangian for symbolic derivation and structural insight.
The Newton-Euler dynamic model is the load-bearing structure of Stage 3. Every controller built in this stage — PID in Lesson 3.4, feedforward in 3.3, LQR in 3.6 — either assumes a dynamic model exists or is derived from one. Getting the model right, including the battery and cable harness, is prerequisite to every controller working correctly on real hardware.
GLOSSARYKey terms introduced
- Newton-Euler equations
- The two coupled equations governing rigid-body motion: f = m·a_c (translational) and τ = Iα + ω×(Iω) (rotational, Euler's equation). Together they form the basis for computing forces and torques in robot dynamic models.
- Inertia tensor
- A 3×3 symmetric matrix I describing a rigid body's resistance to angular acceleration about any axis. Diagonal elements are the principal moments of inertia; off-diagonal products of inertia couple rotation axes and arise from asymmetric mass distributions.
- Newton-Euler recursive algorithm
- A two-pass method for computing robot dynamics: outward sweep propagates velocities and accelerations from base to tip; inward sweep propagates forces and torques from tip to base. Scales as O(N) in the number of joints, making it suitable for real-time control.
- Coriolis term
- The term C(q, q̇)·q̇ in the robot equation of motion, arising from the cross-coupling of simultaneously rotating joints. Proportional to the product of joint velocities (θ̇_i · θ̇_j). Produces instantaneous torque loads that a purely reactive PID controller cannot eliminate without feedforward compensation.
- Equation of motion (robot)
- τ = M(q)·q̈ + C(q,q̇)·q̇ + g(q). The canonical form of robot dynamics: M is the configuration-dependent mass matrix, C·q̇ collects Coriolis/centrifugal terms, g is the gravity vector. Derived from Newton-Euler or Lagrangian formulation; used directly for feedforward control.
- Parallel axis theorem
- I_A = I_CoM + m·d², where d is the distance between the CoM and an arbitrary parallel axis A. Essential for computing inertia about joint axes from CAD-reported CoM inertia values; a common source of dynamic model error when misapplied.
- Feedforward control
- A control strategy that uses the inverse dynamic model to compute the required joint torques for a desired trajectory analytically, adding them to the motor command before error appears. Eliminates systematic tracking errors from Coriolis, centrifugal, and gravity loads. Contrasts with pure PID feedback, which can only correct errors after they occur.
- Sim-to-real gap (dynamics)
- The discrepancy between the dynamic model used in simulation and the actual physical behavior of the robot hardware. Sources include joint friction, link compliance, unmodelled masses, and actuator bandwidth limits. Unlike perception gaps, dynamics gaps are systematic (not random) and can often be identified and compensated explicitly.
ACTIVE RECALLCheck your understanding
Answer in your own words first, then reveal.
1Euler's rotational equation is τ = Iα + ω×(Iω). Under what conditions does the second term vanish, and why does it matter for robot arm control?›
The term ω×(Iω) vanishes when either (a) ω = 0 (the body is not rotating) or (b) ω is aligned with a principal axis of I (so Iω is parallel to ω, making their cross product zero). For a robot arm, condition (a) holds only momentarily at rest positions; condition (b) generally does not hold because the arm is rotating about multiple non-principal axes simultaneously. This matters because the term represents the gyroscopic/Coriolis load — the torque a link must absorb just because it is already spinning while another joint accelerates it. In a fast trajectory, this term can be comparable to or larger than the gravity term. A controller that neglects it systematically underestimates the required joint torques during motion, producing tracking errors that cannot be eliminated by increasing PID gains (higher gains cause oscillation instead).
2The Newton-Euler algorithm has two sweeps: outward and inward. Why does the inward sweep start from the tip rather than the base?›
The inward sweep propagates forces and torques from tip to base because the load each joint must support is the sum of everything distal to it: the next link, all subsequent links, and any end-effector payload. Link N (at the tip) has no distal loads — its joint torque comes only from its own inertia, gravity, and Coriolis terms. Link N-1's joint must support link N's force plus its own terms. And so on back to the base. If you swept inward from the base, you would not yet know the distal loads needed to compute each joint's torque. The tip is where the chain terminates — it is the natural starting point for force propagation because all forces originate from outside the robot (end-effector contact, gravity acting on each link independently), and those forces must be transmitted inward through the chain to the actuators.
3FollowBot's arm shows a systematic 3-5° droop on fully extended trajectories, despite a well-tuned PID. What is the most likely root cause, and where in the dynamic model would you look first?›
The most likely root cause is an error in the gravity vector g(q) — specifically, the center-of-mass position for one or more links. A systematic droop (not random, not velocity-dependent, worsening at full extension) has the signature of a gravity compensation error. In Newton-Euler terms, the gravity torque on joint i is m × g × L_c × cos(θ_i) where L_c is the CoM offset from the joint. An unmodelled battery mass (or a CoM placed at the geometric center instead of the true CoM) reduces L_c in the model relative to reality. The model underestimates gravity torque, the PID integrator partially compensates but cannot fully — because the integrator is rate-limited and a constant offset exactly matches what integrator anti-windup suppresses. Fix: measure the actual CoM on the physical link using the swing-table or triple-pendulum method; update the URDF <inertial> <origin> to match. Do not increase PID gain to compensate for a model error — that masks the problem and reduces stability margin.
4The robot equation of motion is τ = M(q)q̈ + C(q,q̇)q̇ + g(q). If you set C = 0 and g = 0 (ignore dynamics and gravity) and use only a PID on joint angles, under what conditions will the robot still track its trajectory accurately?›
A pure PID without feedforward (C = 0, g = 0 in the model) can track trajectories accurately only when: (1) the trajectory is slow enough that Coriolis and centrifugal loads are small compared to the PID gain × error term, (2) the trajectory does not require holding against gravity (or there is an integral term large enough to compensate — but this windup slows transient response), and (3) the gain crossover frequency of the PID is substantially higher than the trajectory bandwidth. In practice, "slow" means joint velocities much less than 1 rad/s and accelerations much less than the ratio (joint torque limit)/(link inertia). For FollowBot's arm on a figure-eight trajectory at 1 Hz, joint velocities reach ~1.5 rad/s and accelerations ~4 rad/s² — the Coriolis term (proportional to velocity product) and the gravity term are both significant. The PID can maintain approximate tracking but will show velocity-proportional cross-track error during the curved segments of the figure-eight that feedforward compensation eliminates.