3.5.17 · D2Guidance, Navigation & Control (GNC)

Visual walkthrough — INS error propagation — error state equations

3,847 words17 min readBack to topic

Step 0 — Two frames, and the rotation between them

An inertial navigation system (INS) never looks out a window. It sits in the dark and does arithmetic on two things it feels:

  • how hard it is being pushed (the accelerometers),
  • how fast it is turning (the gyros).

Before any equation, we must nail down the two coordinate frames the whole subject lives in.

From the sensors, the INS computes where it thinks it is. But to turn body-frame push into North-East-Down acceleration, it must apply — and if its stored is slightly wrong, everything downstream is wrong. Call the machine's stored, computed nav frame the computed frame, and the honest real one the true frame.

Everything below is the story of how is born, how it leaks into velocity, and how velocity leaks into position.

Figure — INS error propagation — error state equations

Step 1 — The three errors we track

We can't fix what we don't name. The three disagreements that matter:

WHY three, and why in this order? Because they form a chain: tilt corrupts velocity, velocity corrupts position. Writing them top-to-bottom as position, velocity, tilt lets us read the coupling as a flow upward through the stack.

Figure — INS error propagation — error state equations

Step 2 — Position error is the easy one (it's exact)

Start with the one relation that needs no approximation. True motion obeys "position changes at the rate of velocity": The dot on top, , means "rate of change per second" — the derivative. We use the derivative here and nowhere else yet because the only question is "how fast is the position arrow moving?", and that is exactly what a derivative answers.

WHAT we do: nudge both sides. Let the true position gain a small error and the true velocity gain . Subtract the true equation from the nudged one:

  • — the rate at which the position error grows.
  • — the current velocity error, feeding it directly.

WHY it's exact: is a straight-line (linear) relation — no products, no sines. When a relation is already linear, the error obeys the same relation with no leftover terms. Nothing was thrown away.

Figure — INS error propagation — error state equations

Step 3 — Naming the rotation rates and the sensor errors first

Before the velocity equation, we meet every symbol it will use — no symbol may appear un-earned.

WHY name them now? The velocity equation below multiplies the true force by the tilted frame and adds the accelerometer's own lie. If we hadn't already named and the 's, they'd appear as mystery symbols. Now they won't.


Step 4 — How a tilt poisons velocity (the heart of it)

Now the important coupling. The true velocity obeys the mechanization equation (from Strapdown INS Mechanization Equations): where is the nominal gravity vector in the nav frame — a known model of gravity pointing (mostly) Down, whose value the INS looks up from its position; the rotation-rate vectors were defined in Step 3. Write : the felt push, correctly rotated into North-East-Down.

The INS, however, uses its computed orientation , which is tilted from the true by .

So the computed nav-frame force is .

HOW we get the velocity-error equation. Write the INS's computed rate using the computed orientation, the computed velocity , and the accelerometer's own error (defined in Step 3). Subtract the true and keep only first-order terms:

Term by term:

  • — rate the velocity error grows.
  • — the star of the show: tilt × (big specific force) leaks into velocity.
  • — the accelerometer error from Step 3, rotated body→nav by .
  • — the gravity-model error: (INS's looked-up gravity) − (true gravity), developed in Step 4b.
  • — the perturbation of the Coriolis/transport term; its origin is Step 4c.

WHY this term dominates: is large — near gravity, about . Multiply even a milliradian tilt by that and you get a real acceleration error. Tilt is a lever, and is its long arm.

Figure — INS error propagation — error state equations

Step 4b — What is, and how it couples back to position

The INS evaluates gravity at the position it thinks it's at. If that guess is off by , the looked-up gravity is off too.

HOW: gravity is a smooth function of position, so a small position error gives a small gravity error — the first-order Taylor rule "output error = (slope) × (input error)":

  • — the gravity gradient : a table saying how much gravity changes per metre moved. We use a derivative here for the same reason as always — it is the exact tool for "how much does this output shift per unit shift of that input?"

WHY it's usually tiny: near Earth, is about (gravity barely changes over metres), so over short flights this term is negligible. But it does couple back into , so in the full matrix it sits in the velocity-row, position-column slot as — a small feedback we'll place explicitly in Step 5. This gravity feedback is one ingredient of the Schuler oscillation of Schuler Tuning and Oscillation.


Step 4c — Where the Coriolis term comes from (and its sign)

The true velocity equation carries ; the rate vectors were defined in Step 3.

HOW the error term arises. This term appears in the true equation because the nav frame is itself rotating, so velocity written in it acquires Coriolis-type corrections. When we perturb and subtract the true equation, it contributes exactly its own perturbation: The true- part cancels; only the part survives. So the sign and form are inherited directly from the true equation — nothing was assumed. (Treating as fixed drops their own tiny perturbations, a legitimate first-order move.)

WHY it's usually ignorable: is minuscule; over a short flight (Step 7). But over hours this feedback is exactly what bends errors into the Schuler oscillation.


Step 5 — Where the tilt itself comes from (gyro drift)

We've used ; now we earn its own equation. The computed nav frame is spun by the gyros. If a gyro's turn-rate report is wrong by (its drift + noise, defined in Step 3), that error is continuously dumped into the tilt.

  • — rate the tilt grows.
  • — the existing tilt is carried around as the nav frame itself rotates at rate (Step 3).
  • — the engine of long-term error: gyro drift, rotated body→nav by , pours steadily into .

WHY gyro quality rules the long run: drift feeds , feeds (Step 4), feeds (Step 2). Three tanks in a row — see Step 8.


Step 6 — Assembling the matrix

Three boxed equations, one for each stacked error. Line them up and read off the coefficients — this is the system matrix in .

The one repackaging: the velocity equation has , but in the tilt is the state being multiplied, so we must write that term as (matrix). Using the flip rule : The sign flips because we swapped the order of the cross product to pull to the right, and swapping order flips the sign. So the velocity-vs-tilt block of is .

Collecting every block (including the gravity feedback from Step 4b):

Reading each row as "what makes this error grow":

  • Row 1 (position): the lone says — Step 2.
  • Row 2 (velocity): the in the tilt column is the coupling of Step 4 (repackaged); the small in the position column is the gravity feedback of Step 4b; the Coriolis/transport perturbation of Step 4c sits on the diagonal.
  • Row 3 (attitude): only the transport-swirl of Step 5. The drift enters through the noise channel: (Both entries of are the same sensor errors defined in Step 3 — one consistent name throughout.)

WHY the whole thing is linear (the parent stressed this): every step above kept only first-order pieces — one factor of a small error per term, never a product of two. Small × small was dropped. That is the entire meaning of "linearize", and it's what a Kalman filter needs. The small-angle machinery of comes straight from Direction Cosine Matrix and Small-Angle Rotations.


Step 7 — The degenerate & edge cases (never get surprised)

A good map covers every corner. Walk the special inputs:

  • Zero tilt, zero errors (): every rate is zero → the INS stays perfect. Correct: a system with no error and no noise doesn't invent one.
  • Zero specific force (, true free-fall): the block vanishes — tilt no longer poisons velocity. The lever arm is gone. (In practice gravity keeps , so this rarely happens.)
  • Short flight (missile, ~2 min): Earth rate gives rad — under a hundredth of a radian, and negligible too. Drop ; keep only and sensor errors. That single block carries ~80% of short-flight error.
  • Long flight (hours): the dropped Earth-coupling and gravity-gradient terms come back to life and bend the growing horizontal error into a bounded oscillation — the Schuler period ≈ 84 min of Schuler Tuning and Oscillation. Errors sway instead of exploding.
  • not small (crash-level misalignment): our first-order picture breaks — the dropped small×small terms matter — and you must re-align, not linearize.

Step 8 — Counting the integrations (why quadratic, why cubic)

The growth rate is the punchline. Follow a constant source through the tank chain of Steps 2, 4, 5.

Accelerometer bias enters at velocity (Step 4, the channel). Two tanks to position: A bias gives .

Gyro drift enters one tank earlier — at tilt (Step 5). Tilt , then mis-resolved gravity . Three tanks to position:

WHY the difference: count the integrations separating source from position. Bias → 2 → . Drift → 3 → . On a long run, crushes : gyros dominate.


The one-picture summary

One glance, the whole chain: gyro drift → tilt → (× big ) → velocity error → position error , with the accelerometer bias jumping in at the velocity stage, the gravity-gradient feedback nudging velocity back from position, and the Earth-rate feedback (dashed) bending it all into a Schuler sway over hours.

feeds

cross with f_n

adds directly

integrate

gravity gradient

bends into Schuler sway

gyro drift

tilt psi

velocity error

accel bias

position error

Earth rate

Recall Feynman: the whole walkthrough in plain words

Imagine a robot walking blindfolded, keeping a mental picture of "which way is up and North." That mental picture is really a little conversion table — — that turns what its body feels into North-East-Down. Its inner compass drifts a tiny bit every second (that's the gyro drift). So its mental picture slowly tilts — that tilt is . Now, the robot feels a strong push (gravity and thrust, the big arrow ). Because its mental up is tilted, it files that push in slightly the wrong direction — and since the push is strong, even a tiny tilt smears a real chunk of it sideways. That sideways smear is a fake acceleration, so the robot's guessed speed drifts off. And a wrong speed, added up over time, walks its guessed position off the true path. Position is the second bucket after a bias, the third after a drift — that's why a drift's error grows faster (cubic) than a bias's (quadratic). There's even a gentle feedback: a wrong position means the robot looks up gravity at the wrong spot, nudging its speed error back — tiny, but over hours it helps turn the runaway into a slow 84-minute sway. And through all of it we only ever kept the small first-order pieces — which is exactly why the messy nonlinear reality collapses into one tidy linear machine a Kalman filter can steer.


Recall Quick self-check

Why is exact? ::: Because is already linear, so the error obeys the same relation with nothing dropped. Which single block of couples tilt into velocity, and what is its sign? ::: — positive because pulling to the right flips into ; is large (~) so the coupling is strong. What is and where does it sit in ? ::: The gravity-model error from evaluating gravity at the wrong position; it sits in the velocity-row, position-column block as . Why is the convection term negative? ::: Because is bookkept in the turning nav frame; a still tilt appears to swing the opposite way to the frame's rotation, giving the minus. Bias vs drift: which grows position error faster and why? ::: Drift (cubic ) beats bias (quadratic ) because drift sits one integration earlier in the chain.