M6-T1 — What Inertial Sensors Measure

Learning objectives

After this lesson, you should be able to:

• Define specific force and say what an accelerometer reads on the pad, in a burn and in free fall.
• Recover acceleration from the measurement, the attitude and gravity.
• Write the error model of a gyro and an accelerometer with bias, scale factor, misalignment and noise.
• Relate the four sensor grades to the size of the errors they cause over a 60 s hop.

The intuition

UAV M3-T7: IMU noise and bias modelling treats the noise of an IMU as something a filter must tune. This lesson comes before that: what the sensor physically responds to, and how its error terms map onto the model every inertial lesson of this track uses. The numbers are Hopper's, and the goal is to see which error is large and why.

The accelerometer feels support, not motion

Inside an accelerometer a small mass is held by springs. It moves relative to the case only when something pushes on the case. Standing on the pad, the pad pushes up with a force that would produce 1 g, so the sensor reads +9.81 m/s² even though nothing moves. In free fall nothing pushes on the case, so it reads zero, although the acceleration is 9.81 m/s² downward. The quantity the sensor reads is specific force: the non-gravitational force per unit mass. For Hopper in powered flight it is just the thrust divided by the mass, along the body axis. Gravity is invisible to it, and must be added back by the navigation computer from a model.

The gyroscope feels rotation, not angle

A gyroscope reports angular rate. To obtain attitude the rate is integrated, and so is its error: a constant bias of 1°/h gives an attitude error that grows by 1° per hour for ever. This one fact is why inertial navigation drifts. An attitude error tilts the specific force when it is rotated into the navigation frame, which turns a gravity-sized acceleration into a false horizontal acceleration. A tilt of 0.5° at 1.5 g makes a lateral error of 0.125 m/s² (13 mg), larger than a good accelerometer's whole error budget.

The error model, and why it has these terms

Each axis of each sensor delivers its input times a scale factor, plus a bias, plus noise, with cross-coupling between axes from misalignment of the sensor axes and the body axes. The bias has a part that is constant from switch-on (turn-on bias) and a slowly wandering part (bias instability); the noise is white. The next lesson shows how to read the sizes of the white and wandering parts from a record. Table 1 lists classes of sensor (illustrative round numbers for the class, not any product) and the error each makes in a 60 s hop.

An accelerometer reads acceleration minus gravity, and a gyroscope reads rate. Attitude comes from integrating the gyro, so a gyro bias grows into attitude error, and attitude error turns gravity into false acceleration. That chain is the whole reason inertial navigation drifts.

Definitions

Specific force $\mathbf{f}$

The non-gravitational force per unit mass acting on the sensor, in body axes. It is what an accelerometer measures.

Angular rate $\boldsymbol{\omega}_{ib}^b$

The rotation rate of the body frame relative to inertial space, expressed in body axes. It is what a gyroscope measures.

Bias

An offset in the output at zero input. It has a constant turn-on value and a slowly varying in-run part.

Scale factor error $s$

A fractional error in the gain of the sensor, in parts per million.

Misalignment $\mathbf{M}$

Small rotations between the sensor axes and the body axes, and non-orthogonality between sensor axes.

Noise

White noise on the rate (angle random walk) and on the acceleration (velocity random walk), whose size is given per root hour.

Derivation: why the accelerometer reads acceleration minus gravity

A proof mass of mass $\mu$ in a case, with the case accelerating at $\mathbf{a}$ relative to inertial space and gravity $\mathbf{g}$.

1. $$\mu\,\mathbf{a}_{\mathrm{mass}} = \mu\,\mathbf{g} + \mathbf{F}_{\mathrm{spring}}$$

   Newton's law for the proof mass in an inertial frame: two forces act on it, gravity (acting on every mass alike) and the force of the springs.

2. $$\mathbf{a}_{\mathrm{mass}} = \mathbf{a}$$

   In steady state the mass moves with the case, since it does not move relative to it.

3. $$\mathbf{F}_{\mathrm{spring}}/\mu = \mathbf{a} - \mathbf{g}$$

   Solve for the spring force per unit mass. The spring is the only thing the sensor can measure, through the displacement of the proof mass.

4. $$\mathbf{f} \equiv \mathbf{F}_{\mathrm{spring}}/\mu = \mathbf{a} - \mathbf{g}$$

   Define the result as the specific force. Gravity acts on the case and the proof mass alike, so it cancels from every relative displacement, and cannot be sensed.

The effect of a tilt

1. $$\mathbf{a}^n = \mathbf{C}_b^n\mathbf{f}^b + \mathbf{g}^n$$

   Rotate the measured specific force into the navigation frame and add gravity, from the first derivation.

2. $$\hat{\mathbf{C}}_b^n = (\mathbf{I} - [\boldsymbol{\psi}\times])\,\mathbf{C}_b^n$$

   An attitude estimate with a small error vector $\boldsymbol{\psi}$, the form the error equations of the next lessons use.

3. $$\delta\mathbf{a}^n = -[\boldsymbol{\psi}\times]\,\mathbf{C}_b^n\mathbf{f}^b = \mathbf{f}^n \times \boldsymbol{\psi}$$

   The error in acceleration is the cross product of the specific force and the attitude error: perpendicular to both, and of size $|\mathbf{f}|\,|\boldsymbol{\psi}|$.

4. $$|\delta a| = 9.81\cdot\psi\ \text{ in hover}, \qquad 14.7\cdot\psi \ \text{ at 1.5 g}$$

   In hover the specific force has the size of gravity, so a tilt of 1 mrad produces 1 mg of false horizontal acceleration. Larger thrust magnifies it.

The accelerometer cannot sense gravity because gravity acts on the proof mass and the case alike. An attitude error rotates the specific force, and the part of it that leaks into the horizontal is the size of the specific force times the angle.

A worked example

Hopper's vertical plane: pitch $\theta$ from the vertical, a gimbal angle $\delta$, thrust $T$, mass 120 kg.

1. On the pad and in free fall. With the engine off on the pad the accelerometer reads +9.81 m/s² along the axis and the true acceleration is zero. With the engine cut in flight the reading is zero in both axes and the true acceleration is −9.81 m/s². In hover the reading is again 9.81.
2. In a burn. At 1.5 g thrust, pitched 10° with the gimbal at 0.05 rad, the sensor reads (14.70, 0.74) m/s² in (axial, lateral). The true acceleration is (3.28, 4.54) m/s² in (horizontal, vertical).
3. Recovery. Rotating the measurement by the attitude and adding gravity returns (3.2763, 4.5356), identical to the truth to four decimals.
4. A wrong attitude. With the pitch off by 0.5° the recovered horizontal acceleration is wrong by 0.125 m/s², which is 13 mg.
5. Over a 60 s hop. A constant gyro bias gives an attitude error of 0.333° (consumer), 0.050° (industrial), 0.005° (tactical) or 0.0002° (navigation); the same grades give a constant accelerometer bias velocity error of 0.29, 0.06, 0.02 and 0.003 m/s.

import math
import gnckit as g

G0, m0, Tmax = 9.81, 120.0, 2400.0
D2R = math.pi / 180

# Hopper in the vertical plane: x downrange, z up, pitch theta from vertical (positive toward +x), gimbal delta
def accel_true(theta, delta, T, m):
    ax = T / m * math.sin(theta + delta)
    az = T / m * math.cos(theta + delta) - G0
    return ax, az

def specific_force_body(theta, delta, T, m):
    """What the accelerometers measure: thrust per unit mass in the body axes (axial, lateral). Gravity is not sensed."""
    return T / m * math.cos(delta), T / m * math.sin(delta)

print('The accelerometer senses specific force f = a - g, not acceleration a.')
cases = [('on the pad, engine off', 0.0, 0.0, 0.0), ('hover, upright', 0.0, 0.0, m0 * G0),
         ('burn at 1.5 g, pitched 10 deg, gimbal 0.05 rad', 10 * D2R, 0.05, 1.5 * m0 * G0),
         ('engine cut in flight (free fall)', 10 * D2R, 0.0, 0.0)]
for name, th, d, T in cases:
    ax, az = accel_true(th, d, T, m0)
    if T == 0.0 and th == 0.0:
        fb = (G0, 0.0)           # supported by the pad: the pad pushes up with 1 g
        ax, az = 0.0, 0.0
    else:
        fb = specific_force_body(th, d, T, m0)
    print(f'  {name:48s} acceleration ({ax:+6.2f}, {az:+6.2f}) m/s2, accelerometer (axial, lateral) ({fb[0]:+6.2f}, {fb[1]:+6.2f}) m/s2')

# recover the acceleration from the measurement and the attitude: a = R f + g
th, d, T = 10 * D2R, 0.05, 1.5 * m0 * G0
fa, fl = specific_force_body(th, d, T, m0)
ax = math.sin(th) * fa + math.cos(th) * fl
az = math.cos(th) * fa - math.sin(th) * fl - G0
at = accel_true(th, d, T, m0)
print(f'  recovered a = R f + g: ({ax:+.4f}, {az:+.4f}) against truth ({at[0]:+.4f}, {at[1]:+.4f})')
tilt = 0.5 * D2R
print(f'  with a 0.5 degree attitude error the lateral acceleration is wrong by {abs(math.sin(th + tilt) * fa + math.cos(th + tilt) * fl - ax):.4f} m/s2 ({abs(math.sin(th + tilt) * fa + math.cos(th + tilt) * fl - ax) / G0 * 1000:.0f} mg)')

print('Error model per axis: y = (1 + s) u + b + n; grades (illustrative class values, 1 sigma):')
grades = [('consumer MEMS', 20.0, 0.30, 0.5, 0.10), ('industrial MEMS', 3.0, 0.10, 0.10, 0.05),
          ('tactical', 0.3, 0.03, 0.03, 0.01), ('navigation', 0.01, 0.002, 0.005, 0.002)]
print('  grade            gyro bias (deg/h)  ARW (deg/rt-h)  accel bias (mg)  VRW (m/s/rt-h)')
for n, gb, arw, ab, vrw in grades:
    print(f'  {n:16s} {gb:12.2f}  {arw:14.3f}  {ab:15.3f}  {vrw:14.3f}')
print('Direct effect of one term over a 60 s hop (bias taken constant):')
t = 60.0
for n, gb, arw, ab, vrw in grades:
    att = gb * t / 3600.0                              # attitude error from the gyro bias, degrees
    vel = ab * 1e-3 * G0 * t                            # velocity error from the accelerometer bias, m/s
    print(f'  {n:16s} attitude error {att:8.4f} deg ({att * D2R * 1000:6.3f} mg of false horizontal acceleration at 1 g), velocity error {vel:.3f} m/s')

The accelerometer senses specific force f = a - g, not acceleration a.
  on the pad, engine off                           acceleration ( +0.00,  +0.00) m/s2, accelerometer (axial, lateral) ( +9.81,  +0.00) m/s2
  hover, upright                                   acceleration ( +0.00,  +0.00) m/s2, accelerometer (axial, lateral) ( +9.81,  +0.00) m/s2
  burn at 1.5 g, pitched 10 deg, gimbal 0.05 rad   acceleration ( +3.28,  +4.54) m/s2, accelerometer (axial, lateral) (+14.70,  +0.74) m/s2
  engine cut in flight (free fall)                 acceleration ( +0.00,  -9.81) m/s2, accelerometer (axial, lateral) ( +0.00,  +0.00) m/s2
  recovered a = R f + g: (+3.2763, +4.5356) against truth (+3.2763, +4.5356)
  with a 0.5 degree attitude error the lateral acceleration is wrong by 0.1251 m/s2 (13 mg)
Error model per axis: y = (1 + s) u + b + n; grades (illustrative class values, 1 sigma):
  grade            gyro bias (deg/h)  ARW (deg/rt-h)  accel bias (mg)  VRW (m/s/rt-h)
  consumer MEMS           20.00           0.300            0.500           0.100
  industrial MEMS          3.00           0.100            0.100           0.050
  tactical                 0.30           0.030            0.030           0.010
  navigation               0.01           0.002            0.005           0.002
Direct effect of one term over a 60 s hop (bias taken constant):
  consumer MEMS    attitude error   0.3333 deg ( 5.818 mg of false horizontal acceleration at 1 g), velocity error 0.294 m/s
  industrial MEMS  attitude error   0.0500 deg ( 0.873 mg of false horizontal acceleration at 1 g), velocity error 0.059 m/s
  tactical         attitude error   0.0050 deg ( 0.087 mg of false horizontal acceleration at 1 g), velocity error 0.018 m/s
  navigation       attitude error   0.0002 deg ( 0.003 mg of false horizontal acceleration at 1 g), velocity error 0.003 m/s

In robotics

The error model is used in three ways: to choose a sensor, to design the estimator, and to simulate.

• Choosing a grade. The four grades above span a factor of 2000 in gyro bias. A 60 s hop does not need a navigation-grade gyro, but it does need better than a consumer one: the budget lesson of this module turns the table into a decision.
• Calibration. Scale factor and misalignment are stable and can be calibrated in the factory or on a turntable, and the corrected output has the remaining residual in the model. Turn-on bias is calibrated at rest before each flight, which is what initial alignment, two lessons ahead, does.
• Simulation. Every estimator in module 7 is tested by feeding it sensor output made from the model with the right numbers. A simulation that omits the bias drift gives an optimistic filter.
• Environmental effects. Temperature changes biases and scale factors, vibration rectifies into bias (the coning and sculling effects of the next lessons), and a g-sensitivity of the gyro couples specific force into the rate. These are the usual reasons that a sensor is worse in flight than on the bench.
• Not a measurement of motion. A common error in a first estimator is to treat the accelerometer as a measure of acceleration, forgetting gravity, and to wonder why a still vehicle appears to climb at 1 g.

The next lesson reads the noise and bias numbers of a particular sensor off a record, and the lab M6-L1: Read the Allan Plot asks you to pick one of three gyros from such records. The attitude error propagation used above is the starting point of M6-T4: INS Error Dynamics and the Schuler Oscillation.

Common misconceptions

Key takeaways

1. An accelerometer measures specific force $\mathbf{f} = \mathbf{a} - \mathbf{g}$: 1 g on the pad, zero in free fall.
2. A gyroscope measures angular rate; attitude is its integral, with the error integrated too.
3. The navigation equation is $\mathbf{a}^n = \mathbf{C}_b^n\mathbf{f}^b + \mathbf{g}^n$, and an attitude error gives an acceleration error $\mathbf{f}^n \times \boldsymbol{\psi}$.
4. The error model is scale factor, misalignment, bias (turn-on and drift) and white noise, per axis.
5. In a 60 s hop a consumer gyro bias (20°/h) tilts the vehicle by 0.33°, a tactical one by 0.005°.
6. Sensor grades in this track are illustrative class values, to be replaced by data sheet numbers.

References and further reading

Each source is marked free or paid. Free to read does not mean free to reuse: the course resources page lists every source with its licence.

• P. D. Groves, Principles of GNSS, Inertial, and Multisensor Integrated Navigation Systems, 2nd edition, Artech House, 2013, chapter 4 on inertial sensors and their errors. Paid.
• D. H. Titterton and J. L. Weston, Strapdown Inertial Navigation Technology, 2nd edition, IET, 2004, the chapters on gyroscopes, accelerometers and error models. Paid.
• IEEE Std 952-1997, Standard Specification Format Guide and Test Procedure for Single-Axis Interferometric Fiber Optic Gyros, the terminology of bias and random walk. Paid.
• MIT 16.333 Aircraft Stability and Control (OpenCourseWare) , for the sensors and axes used in flight dynamics. Free; licence CC BY-NC-SA 4.0.

Knowledge check

Three questions. Write an answer, then reveal the explanation. Your answers stay in your browser.

What’s next

Related content

Nothing below is required to finish this lesson.

• Lab
  M6-L1: Read the Allan Plot

  Three gyros were logged at rest for an hour. Compute their Allan deviations, extract the noise coefficients, and pick the one that meets a heading-drift requirement.

Other courses on this site treat neighbouring topics from their own angle:

• UAV M2-T7: Inertial Navigation Systems
• UAV M2-T8: Dead reckoning and inertial drift
• UAV M3-T7: IMU noise and bias modelling
• UAV M3-T8: IMU preintegration
• UAV M1-T8: IMU, barometer, magnetometer and GNSS
• Probability M2-T4: Distributions of Real Sensor Noise
• Probability M5-T4: Identifying Noise Parameters from Data
• Linear Algebra M10-T6: Small-Angle Approximations

This course leaves the following to the pages that already teach them:

• What an INS is and why it drifts, without the equations
• IMU preintegration for factor-graph estimators
• Wheel odometry and its motion models