How Loosely Coupled INS/GNSS Integration Works

Here is the problem this lecture is about. A vehicle has to report where it is and how fast it is going, continuously, at high rate, for an hour, in open sky and under a bridge. Two instruments can answer that, and each of them fails in a way the other one does not. The first is an inertial measurement unit. Three accelerometers and three gyroscopes, bolted to the vehicle frame, reporting specific force and angular rate in their own body axes, several hundred times a second. Nothing in that list refers to the world outside the vehicle. Mechanization is the arithmetic that turns those two signals into a navigation solution. Integrate angular rate to keep attitude. Rotate the measured force into navigation axes, add gravity back, and integrate to get velocity. Integrate once more to get position. Every one of those integrals also integrates the sensor's own errors, and that is the whole trouble. A constant accelerometer bias, half a milli-g, say, becomes a velocity error that grows linearly and a position error that grows as one half b t squared. Here is what that costs, drawn against time in seconds, with metres of position error up the side. It is smooth, and it is quiet, and it climbs: past ten metres, past twenty metres, and it never comes back down. So an unaided inertial system is superb over seconds and useless over minutes. And notice which part is bad. The shape of the trajectory is excellent; it is the absolute placement that slides away. The second instrument does the opposite. A satellite receiver measures its distance to every satellite it can see, and with four or more of those distances it solves directly for three coordinates of position, and for its own clock offset, which is the fourth unknown. What comes out is an absolute fix: position, and usually velocity, expressed in an earth-fixed frame and referred to nothing but the satellites. It arrives slowly by inertial standards, one to ten times a second. And it is noisy. Receiver noise, unmodelled atmospheric delay, and signals that arrive after bouncing off a building, which is what multipath means, all move the reported fix by metres from one epoch to the next. Here it is on the same axes. But watch what it does not do. It wanders, and it keeps wandering about the same level, under about five metres, and it does not care whether you have been driving for one minute or five hours. Its error is bounded. The inertial error is not. Put them side by side and the pattern is almost too convenient. The inertial unit is fast, smooth and locally accurate, and it drifts. The receiver is slow and noisy, and it does not drift. One more line matters later. The inertial unit needs nothing outside the vehicle at all, while the receiver needs a clear view of at least four satellites, and that is the one place the scheme we are about to build gives up. So neither instrument is the answer; the pair is. And this is what the pair can do: an error that is smooth and fast like the inertial solution, and bounded like the satellite one. Building that blue curve is the whole of this lecture.

So we build the pair. Loosely coupled integration is one particular way of wiring them together, and it is the one to meet first, because every piece of it can be bought, tested and replaced on its own. The top row is the inertial chain. The measurement unit hands its samples to the mechanization we just wrote down, and out comes a continuous solution: position, velocity and attitude, at the full sensor rate. Underneath, and quite separately, sits the receiver. It tracks whatever satellites it can see and solves its own navigation problem, on its own schedule, and what leaves it is a computed fix. Now the filter. It does not sit in the signal path at all. Both solutions are handed to it, and what it estimates is not where the vehicle is, but how wrong the inertial solution has become. Its measurement is therefore a difference. Take the inertial position and velocity, subtract the position and velocity the receiver reported, and what is left is error: the inertial system's error, plus the receiver's noise. And the corrections travel back up the same interface. The estimated error is written into the mechanization, and the estimated sensor biases are subtracted from the incoming samples, so the errors the filter is linearising about stay small. The word loosely is a statement about that interface. What crosses between the two systems is a finished navigation solution, six numbers. The individual satellite ranges never leave the receiver, and the receiver never hears about the inertial unit. Why estimate the error rather than the state? Look at what the error is. Here is the true path of the vehicle in grey, and here is the path the mechanization computed, in red. The shapes agree very well. The placement does not. The difference between those two paths is small, it is slowly varying, and to first order it obeys linear dynamics. That is the whole reason for the indirect formulation: the vehicle's motion is thoroughly nonlinear, but its error is not. So we do not ask the filter for the vehicle's position. We ask it for fifteen numbers that say how wrong the inertial solution is: three of position, three of velocity, three of attitude, and six sensor biases, three per triad. Those fifteen errors evolve according to a matrix F built from the current attitude, the current specific force and the bias models, plus process noise for everything F leaves out. That is the propagation half of the filter. Now the measurement. It is the inertial solution minus the receiver's solution, and nothing else. Write each of them as the truth plus its own error, and the truth cancels. What is left is the position and velocity part of the error state, minus the receiver's noise. So the measurement matrix is almost embarrassingly simple: identity on six of the fifteen states, zero on the other nine. That is the entire measurement model of a loosely coupled filter. And notice what is not in there. No satellite geometry, no ranges, no clock. All of that stayed inside the receiver, which is exactly what makes this scheme modular, and also exactly what will limit it.

Now the filter itself. It alternates between two steps, and the interesting thing about this architecture is how little happens in the first of them. Between fixes there is no measurement, so nothing corrects anything at all. The mechanization runs on at full rate, the error grows exactly as it did unaided, and all the filter can do is keep track of how uncertain that growing solution has become. The prediction is the ordinary Kalman one, on the error state. Because the last correction was written straight into the mechanization, the error estimate starts each interval at zero. The transition matrix over one interval is the identity plus F delta t, and the covariance is pushed through it and grown by the process noise. Watch the picture while that runs. Nothing on it improves. Between fixes, a loosely coupled system is an unaided inertial system with a growing covariance attached to it. Then a fix arrives, and everything happens at once. The innovation is the difference we built a moment ago, less whatever the filter already expected that difference to be. Here it expected zero, so the innovation is the raw difference. The gain weighs the two sides against each other. The middle term, S, is how large a difference we should have expected, given our own uncertainty and the receiver's noise. When the receiver is noisy and the filter is confident, the correction is small. When the inertial solution has been coasting a long time, it is large. The correction is applied to the whole error state, not only to the six states we measured. Position error is observed directly. Attitude error and the gyro biases are not, and they are estimated anyway, because the covariance says they are correlated with what we did measure. And the covariance shrinks, which is the part that matters most. The filter is now more certain than it was, and the next coasting interval starts from a smaller number. Then it all repeats. And here is what to watch across several cycles: the teeth are getting shorter. Nearly nine metres on the first, under six on the next, then four. Each fix does more than reset the error; it also improves the estimate of the biases that were making it grow. That improvement deserves its own picture. This is the filter's estimate of one accelerometer bias against time, in milli-g, with the true value dashed across it at eight. It starts at zero, because we knew nothing, and it walks up to the truth over a minute or two of driving. A bias on an accelerometer produces a velocity error that grows in a particular direction, and every fix reports that direction again. So the filter is calibrating the instrument while the vehicle drives. Which brings us to where the correction is actually applied, and there are two choices. In the feedback configuration the estimate is written into the mechanization: position, velocity and attitude are overwritten, the estimated biases are subtracted from the incoming samples, and the error estimate is then reset to zero. In the feedforward configuration the mechanization is left running untouched, and the correction is added to its output instead. That is easier to bolt onto an existing box, but the inertial solution keeps drifting underneath, so the errors the filter linearised about stop being small. Feedback keeps them small. So the loop is four words: coast, compare, correct, calibrate. And note where the navigation solution comes from. It is produced entirely by the mechanization; the filter never computes a position, only a correction to one.

Two things left: what this arrangement buys, and the one place it stops working. The second is easier to see, so start there. On the left, the number of satellites the receiver can use; on the right, the error of the integrated solution over the same half minute. With six satellites in view the fixes keep arriving, once a second, and the error stays well under five metres: the sawtooth we have just been watching, on a coarser scale. Then the vehicle turns into a street with tall buildings on both sides, and the usable count falls to three. Four independent ranges are needed for three coordinates and the clock offset, so with three the receiver publishes nothing at all. And a loosely coupled filter has nothing to do with three ranges. Its measurement is a position and velocity solution, and there is no solution, so there is no update: no innovation, no gain, no correction. The filter coasts, and what you are watching is once again the unaided inertial error. Ten seconds of that, and the solution is nearly twenty metres out. Then the street opens, the satellites come back, and the very first fix pulls the whole thing down again. The recovery is immediate: the filter kept a valid covariance the whole way through the gap, so it knows exactly how little to trust itself. So here is the trade, and it is a clear one. On the gain side: the receiver is a box you can buy, qualify and replace, and the filter never touches its internals. The measurement model is six states of identity, so the code is small and the update is cheap. And you have two solutions that can check each other. On the other side: the receiver has already filtered its own output, so consecutive fixes are correlated and the noise covariance you assume is optimistic. The fix is old when it arrives, so it must be time-tagged and applied to the instant it belongs to. And below four satellites there is no measurement at all. None of that is a reason to avoid the architecture. It is a reason to know which failure you are buying. This filter is exactly as available as the receiver's position solution, and no more. If you need aiding below four satellites, you need a different interface, and that is what a tightly coupled design is for. So, the whole thing in one line. The navigation solution is the mechanization's own, corrected by an estimate of its own error, and that estimate is driven by nothing more than the difference between two independent solutions to the same problem. The inertial unit supplies continuity, smoothness and rate. The receiver supplies an absolute reference. And the error-state filter in between carries the calibration from one fix to the next, which is why the solution keeps its accuracy through the ten seconds when nobody is checking it.