Quadrotor dynamics in 15 minutes

A quadrotor has 6 DOF (3 position + 3 orientation) but only 4 actuators (rotor speeds). It's underactuated. It's fast. The dynamics are nonlinear but exhibit a special property — differential flatness — that lets you plan smooth trajectories analytically. That's why drone racing exists. Here's the model and the control hierarchy that flies one.

The body

Four rotors at the corners of an X (or +) frame. Each rotor produces:

• Thrust $$F_i\propto {\omega }_i^2$$ — proportional to rotor angular velocity squared, perpendicular to the rotor plane.
• Reaction torque $$M_i\propto {\omega }_i^2$$ — about the rotor's spin axis, opposite to its rotation.

Diagonal rotors spin in the same direction; adjacent rotors spin opposite. Net reaction torque cancels in hover. Differential changes produce yaw.

Four control inputs

Combine the four rotor speeds into four virtual inputs:

• $$u_1$$: total thrust (sum of all four)
• $$u_2$$: roll torque (left vs right)
• $$u_3$$: pitch torque (front vs back)
• $$u_4$$: yaw torque (diagonal vs diagonal)

Map them back to per-rotor speeds via a 4×4 mixer matrix:

$$\left[\begin{array}{c}{\omega }_1^2\\ {\omega }_2^2\\ {\omega }_3^2\\ {\omega }_4^2\end{array}\right]=M^{-1}\left[\begin{array}{c}{u}_1\\ u_2\\ u_3\\ u_4\end{array}\right]$$

Inversion is constant; computed once at boot.

The dynamics

Let $\mathbf{p}=(x,y,z)$ be position, $R$ be the rotation matrix from body to world, and $\mathbf{\omega }$ be body angular velocity. Newton-Euler:

$$m\ddot{\mathbf{p}}=-mg\hat{\mathbf{z}}+R(u_1{\hat{\mathbf{z}}}_b)$$ $$J\dot{\mathbf{\omega }}=-\mathbf{\omega }\times J\mathbf{\omega }+(u_2,u_3,u_4{)}^T$$

$J$ is the body inertia tensor. The first equation says: total thrust acts along the body z-axis (upward through the body), gravity always pulls down. The second is rotational dynamics with cross-product Coriolis term.

Crucially: there's no input that produces lateral force directly. To translate sideways, the quadrotor must tilt first — that's the underactuation.

The controller hierarchy

Almost every quadrotor controller has three nested loops, fastest to slowest:

1. Rate controller (1–4 kHz): given desired body angular velocities ${\mathbf{\omega }}_d$, command rotor torques $u_2,u_3,u_4$. Usually PID per axis.
2. Attitude controller (~500 Hz): given desired body orientation $R_d$, output ${\mathbf{\omega }}_d$. Often an SO(3) error, ${\mathbf{\omega }}_d=K_R{e}_R$.
3. Position controller (~100 Hz): given desired position trajectory, output desired thrust $u_1$ and desired body orientation $R_d$. PID or LQR or MPC.

The position controller computes a desired total acceleration vector ${\mathbf{a}}_d$. Total thrust = $$u_1=m||{\mathbf{a}}_d+g\hat{\mathbf{z}}||$$. Desired body z-axis = direction of ${\mathbf{a}}_d+g\hat{\mathbf{z}}$. Combined with desired yaw, that gives $R_d$, which feeds the attitude loop.

Differential flatness

Quadrotor dynamics have a remarkable property: any sufficiently smooth trajectory in the four "flat outputs" — $$(x,y,z,\psi )$$ (position + yaw) — can be tracked exactly. Given $$\mathbf{p}(t),\psi (t)$$, you can analytically recover the required orientation and rotor torques.

This is huge. Without flatness, planning a quadrotor trajectory is a nonlinear-control problem. With it, you plan a smooth $$\mathbf{p}(t)$$ (e.g. a 7th-degree polynomial through waypoints, minimizing snap), and the controller can follow it perfectly.

This is why aggressive drone racing trajectories work: they're polynomial-flat-output trajectories with provable feasibility. Mellinger and Kumar's 2011 paper formalized it; every modern quadrotor planner uses it.

Snap-minimization for trajectories

What polynomial degree to use? It turns out:

• Snap = 4th derivative of position. Roughly proportional to the rate of change of body forces.
• A trajectory that minimizes integrated snap squared, subject to passing through waypoints, is the smoothest physically feasible motion.
• Closed-form solution via QP. Each segment is a 7th-order polynomial.

Result: smooth, fast, dynamically-feasible drone flights from waypoints. Run on tiny CPUs. The math is in Mellinger's paper.

Hover linearization

For most stationary or slow-moving applications, linearize around hover ($$R=I,\omega =0$$):

$$\ddot{x}=g\theta ,\ddot{y}=-g\varphi ,\ddot{z}=u_1/m-g,\dot{\varphi }={\omega }_x,\dot{\theta }={\omega }_y,\dot{\psi }={\omega }_z$$

Where $$\varphi ,\theta ,\psi$$ are roll, pitch, yaw. Decoupled; LQR or PID per axis works directly.

This is what consumer-drone autopilots (Pixhawk, ArduPilot) do at the low level. Aggressive flight needs the full nonlinear model.

The state estimation problem

Position and orientation aren't directly measured. You fuse:

• IMU (gyro + accelerometer) at 1 kHz — gives angular rate and "specific force."
• GPS at 5–10 Hz — outdoor position, slow.
• Visual-inertial odometry (camera + IMU) — indoor or GPS-denied positions.
• Optical flow from downward camera — short-range velocity estimate.
• Barometer — altitude.

Standard fusion: EKF or UKF. Recent state-of-the-art uses tightly-coupled VIO (e.g., VINS-Fusion) for indoor flight without GPS.

Common gotchas

• Saturation: max rotor speed is finite. Aggressive maneuvers can saturate one rotor while others have headroom — the actual achievable acceleration is bounded by the most-saturated rotor.
• Battery sag: as battery voltage drops, max thrust decreases. The same throttle command produces less force. Compensate with model-predictive thrust.
• Wind: substantial unmodeled disturbance. Use disturbance observers or wind-feedforward.
• Yaw drift: pure IMU integration of yaw drifts. Magnetometer or visual yaw is required for long flights.

The 2026 quadrotor stack

• PX4 / ArduPilot: the open autopilots. PID + complementary filter; production-ready.
• Crazyswarm: research swarm framework on Crazyflie hardware.
• Differential-flatness MPC: aggressive racing controllers, e.g., the recent Swift drone-racing work from UZH.
• Learning-augmented controllers: residual policies on top of differential-flatness MPC. Used for unmodeled dynamics like ground effect.

Exercise

In a quadrotor sim (Crazyflie sim, or PyBullet's quadrotor), implement the three-loop hierarchy. Tune the rate loop first, then attitude, then position — outside-in won't work. Achieve hover, then track a circle, then a figure-8. The small step from "hover" to "fly a path" is bigger than it looks; once you've debugged it, you've earned the right to read aggressive-flight papers.

That's the Kinematics track done

You've covered the full progression: forward kinematics → rigid-body transforms → DH and PoE notation → analytical and iterative IK → Jacobians → Lagrangian dynamics → mobile robots → quadrotors. With this, you can write the kinematics layer of any robot project from scratch, and read the literature without flinching at the math. Next steps depend on your project: dynamics-rich research (read more in the Control track), or applied work (jump to Manipulation, Mobile & Legged, or SLAM).